@iservice365/module-hygiene 0.1.2 → 0.2.0

package/dist/index.js

@@ -33,32 +33,21 @@ __export(src_exports, {
   MArea: () => MArea,
   MAreaChecklist: () => MAreaChecklist,
   MParentChecklist: () => MParentChecklist,
-  MScheduleTaskArea: () => MScheduleTaskArea,
-  MToiletLocation: () => MToiletLocation,
   MUnit: () => MUnit,
   MUnitChecklist: () => MUnitChecklist,
-  allowedStatus: () => allowedStatus,
-  allowedTypes: () => allowedTypes,
+  allowedChecklistStatus: () => allowedChecklistStatus,
   areaChecklistSchema: () => areaChecklistSchema,
   areaSchema: () => areaSchema,
   parentChecklistSchema: () => parentChecklistSchema,
-  scheduleTaskAreaSchema: () => scheduleTaskAreaSchema,
-  toiletLocationSchema: () => toiletLocationSchema,
   unitChecklistSchema: () => unitChecklistSchema,
   unitSchema: () => unitSchema,
   useAreaChecklistController: () => useAreaChecklistController,
   useAreaChecklistRepo: () => useAreaChecklistRepo,
   useAreaController: () => useAreaController,
-  useAreaRepository: () => useAreaRepository,
+  useAreaRepo: () => useAreaRepo,
   useAreaService: () => useAreaService,
   useParentChecklistController: () => useParentChecklistController,
   useParentChecklistRepo: () => useParentChecklistRepo,
-  useScheduleTaskAreaController: () => useScheduleTaskAreaController,
-  useScheduleTaskAreaRepository: () => useScheduleTaskAreaRepository,
-  useScheduleTaskAreaService: () => useScheduleTaskAreaService,
-  useToiletLocationController: () => useToiletLocationController,
-  useToiletLocationRepository: () => useToiletLocationRepository,
-  useToiletLocationService: () => useToiletLocationService,
   useUnitChecklistController: () => useUnitChecklistController,
   useUnitChecklistRepo: () => useUnitChecklistRepo,
   useUnitController: () => useUnitController,
@@ -71,16 +60,25 @@ module.exports = __toCommonJS(src_exports);
 var import_node_server_utils = require("@iservice365/node-server-utils");
 var import_joi = __toESM(require("joi"));
 var import_mongodb = require("mongodb");
+
+// src/models/hygiene-base.model.ts
+var allowedTypes = ["common", "toilet"];
+var allowedStatus = ["ready", "ongoing", "completed"];
+
+// src/models/hygiene-area.model.ts
 var areaSchema = import_joi.default.object({
-  name: import_joi.default.string().required(),
   site: import_joi.default.string().hex().required(),
-  createdBy: import_joi.default.string().hex().required(),
-  checklist: import_joi.default.array().items(
+  name: import_joi.default.string().required(),
+  type: import_joi.default.string().valid(...allowedTypes).required(),
+  set: import_joi.default.number().min(0).optional(),
+  units: import_joi.default.array().items(
     import_joi.default.object({
-      _id: import_joi.default.string().hex().required(),
+      unit: import_joi.default.string().hex().required(),
       name: import_joi.default.string().required()
-    })
-  ).optional()
+    }).optional()
+  ).min(1).unique("unit", { ignoreUndefined: true }).messages({
+    "array.unique": "Duplicate area units are not allowed"
+  })
 });
 function MArea(value) {
   const { error } = areaSchema.validate(value);
@@ -95,56 +93,58 @@ function MArea(value) {
       throw new import_node_server_utils.BadRequestError("Invalid site ID format.");
     }
   }
-  if (value.createdBy) {
-    try {
-      value.createdBy = new import_mongodb.ObjectId(value.createdBy);
-    } catch (error2) {
-      throw new import_node_server_utils.BadRequestError("Invalid createdBy ID format.");
-    }
-  }
-  if (value.checklist && Array.isArray(value.checklist)) {
-    value.checklist = value.checklist.map((item) => {
+  if (value.units && Array.isArray(value.units)) {
+    value.units = value.units.map((item) => {
       try {
         return {
           ...item,
-          _id: new import_mongodb.ObjectId(item._id)
+          unit: new import_mongodb.ObjectId(item.unit)
         };
       } catch (error2) {
-        throw new import_node_server_utils.BadRequestError(
-          `Invalid checklist item ID format: ${item._id}`
-        );
+        throw new import_node_server_utils.BadRequestError(`Invalid unit ID format: ${item.unit}`);
       }
     });
   }
   return {
-    name: value.name,
     site: value.site,
-    createdBy: value.createdBy,
-    checklist: value.checklist,
-    status: value.status ?? "active",
+    name: value.name,
+    type: value.type,
+    set: value.set ?? 0,
+    units: value.units ?? [],
+    status: "active",
     createdAt: /* @__PURE__ */ new Date(),
-    updatedAt: value.updatedAt ?? "",
-    deletedAt: value.deletedAt ?? ""
+    updatedAt: "",
+    deletedAt: ""
   };
 }
 
 // src/repositories/hygiene-area.repository.ts
 var import_mongodb2 = require("mongodb");
 var import_node_server_utils2 = require("@iservice365/node-server-utils");
-function useAreaRepository() {
+
+// src/utils/capitalize-text.ts
+function capitalizeText(text) {
+  if (!text)
+    return "";
+  return text.toLowerCase().split(" ").map((word) => word.charAt(0).toUpperCase() + word.slice(1)).join(" ");
+}
+
+// src/repositories/hygiene-area.repository.ts
+function useAreaRepo() {
   const db = import_node_server_utils2.useAtlas.getDb();
   if (!db) {
     throw new import_node_server_utils2.InternalServerError("Unable to connect to server.");
   }
-  const namespace_collection = "hygiene-areas";
+  const namespace_collection = "site.cleaning.areas";
   const collection = db.collection(namespace_collection);
   const { delNamespace, setCache, getCache } = (0, import_node_server_utils2.useCache)(namespace_collection);
   async function createIndex() {
     try {
       await collection.createIndexes([
         { key: { site: 1 } },
-        { key: { createdBy: 1 } },
-        { key: { status: 1 } }
+        { key: { type: 1 } },
+        { key: { status: 1 } },
+        { key: { "units.unit": 1 } }
       ]);
     } catch (error) {
       throw new import_node_server_utils2.InternalServerError("Failed to create index on hygiene area.");
@@ -162,7 +162,7 @@ function useAreaRepository() {
   async function createUniqueIndex() {
     try {
       await collection.createIndex(
-        { name: 1, site: 1, deletedAt: 1 },
+        { site: 1, name: 1, type: 1, deletedAt: 1 },
         { unique: true }
       );
     } catch (error) {
@@ -187,7 +187,9 @@ function useAreaRepository() {
     } catch (error) {
       const isDuplicated = error.message.includes("duplicate");
       if (isDuplicated) {
-        throw new import_node_server_utils2.BadRequestError("Area already exists.");
+        throw new import_node_server_utils2.BadRequestError(
+          `${capitalizeText(value.type)} area already exists.`
+        );
       }
       throw error;
     }
@@ -196,9 +198,7 @@ function useAreaRepository() {
     page = 1,
     limit = 10,
     search = "",
-    startDate = "",
-    endDate = "",
-    site = ""
+    site
   }) {
     page = page > 0 ? page - 1 : 0;
     const query = {
@@ -208,32 +208,17 @@ function useAreaRepository() {
       page,
       limit
     };
-    if (site) {
-      try {
-        site = new import_mongodb2.ObjectId(site);
-        cacheOptions.site = site.toString();
-      } catch (error) {
-        throw new import_node_server_utils2.BadRequestError("Invalid site ID format.");
-      }
+    try {
+      site = new import_mongodb2.ObjectId(site);
+      query.site = site;
+      cacheOptions.site = site.toString();
+    } catch (error) {
+      throw new import_node_server_utils2.BadRequestError("Invalid site ID format.");
     }
     if (search) {
       query.$or = [{ name: { $regex: search, $options: "i" } }];
       cacheOptions.search = search;
     }
-    if (startDate && endDate) {
-      query.createdAt = {
-        $gte: new Date(startDate),
-        $lte: new Date(endDate)
-      };
-      cacheOptions.startDate = new Date(startDate).toISOString().split("T")[0];
-      cacheOptions.endDate = new Date(endDate).toISOString().split("T")[0];
-    } else if (startDate) {
-      query.createdAt = { $gte: new Date(startDate) };
-      cacheOptions.startDate = new Date(startDate).toISOString().split("T")[0];
-    } else if (endDate) {
-      query.createdAt = { $lte: new Date(endDate) };
-      cacheOptions.endDate = new Date(endDate).toISOString().split("T")[0];
-    }
     const cacheKey = (0, import_node_server_utils2.makeCacheKey)(namespace_collection, cacheOptions);
     const cachedData = await getCache(cacheKey);
     if (cachedData) {
@@ -243,45 +228,11 @@ function useAreaRepository() {
     try {
       const items = await collection.aggregate([
         { $match: query },
-        {
-          $lookup: {
-            from: "sites",
-            localField: "site",
-            foreignField: "_id",
-            pipeline: [{ $project: { name: 1 } }],
-            as: "site"
-          }
-        },
-        {
-          $unwind: {
-            path: "$site",
-            preserveNullAndEmptyArrays: true
-          }
-        },
-        {
-          $lookup: {
-            from: "users",
-            localField: "createdBy",
-            foreignField: "_id",
-            pipeline: [{ $project: { name: 1 } }],
-            as: "createdBy"
-          }
-        },
-        {
-          $unwind: {
-            path: "$createdBy",
-            preserveNullAndEmptyArrays: true
-          }
-        },
         {
           $project: {
             name: 1,
-            site: "$site._id",
-            siteName: "$site.name",
-            createdByName: "$createdBy.name",
-            checklist: 1,
-            status: 1,
-            createdAt: 1
+            type: 1,
+            set: 1
           }
         },
         { $sort: { _id: -1 } },
@@ -300,6 +251,47 @@ function useAreaRepository() {
       throw error;
     }
   }
+  async function getAreasForChecklist({
+    site,
+    type
+  }) {
+    const query = { type, status: { $ne: "deleted" } };
+    const cacheOptions = { type };
+    try {
+      site = new import_mongodb2.ObjectId(site);
+      query.site = site;
+      cacheOptions.site = site.toString();
+    } catch (error) {
+      throw new import_node_server_utils2.BadRequestError("Invalid site ID format.");
+    }
+    const cacheKey = (0, import_node_server_utils2.makeCacheKey)(namespace_collection, cacheOptions);
+    const cachedData = await getCache(cacheKey);
+    if (cachedData) {
+      import_node_server_utils2.logger.info(`Cache hit for key: ${cacheKey}`);
+      return cachedData;
+    }
+    try {
+      const items = await collection.aggregate([
+        { $match: query },
+        {
+          $project: {
+            name: 1,
+            set: 1,
+            units: 1
+          }
+        },
+        { $sort: { _id: -1 } }
+      ]).toArray();
+      setCache(cacheKey, items, 15 * 60).then(() => {
+        import_node_server_utils2.logger.info(`Cache set for key: ${cacheKey}`);
+      }).catch((err) => {
+        import_node_server_utils2.logger.error(`Failed to set cache for key: ${cacheKey}`, err);
+      });
+      return items;
+    } catch (error) {
+      throw error;
+    }
+  }
   async function getAreaById(_id) {
     try {
       _id = new import_mongodb2.ObjectId(_id);
@@ -324,11 +316,12 @@ function useAreaRepository() {
         {
           $project: {
             name: 1,
-            checklist: 1
+            set: 1,
+            units: 1
           }
         }
       ]).toArray();
-      if (!data || !data.length) {
+      if (!data || data.length === 0) {
         throw new import_node_server_utils2.NotFoundError("Area not found.");
       }
       setCache(cacheKey, data[0], 15 * 60).then(() => {
@@ -341,22 +334,6 @@ function useAreaRepository() {
       throw error;
     }
   }
-  async function getAreaByName(name, site) {
-    try {
-      if (site)
-        site = new import_mongodb2.ObjectId(site);
-    } catch (error) {
-      throw new import_node_server_utils2.BadRequestError("Invalid site ID format.");
-    }
-    try {
-      return await collection.findOne({
-        name: { $regex: new RegExp(`^${name}$`, "i") },
-        ...site && { site }
-      });
-    } catch (error) {
-      throw new import_node_server_utils2.BadRequestError("Unable to fetch area by name.");
-    }
-  }
   async function updateArea(_id, value) {
     try {
       _id = new import_mongodb2.ObjectId(_id);
@@ -364,7 +341,30 @@ function useAreaRepository() {
       throw new import_node_server_utils2.BadRequestError("Invalid area ID format.");
     }
     try {
-      const updateValue = { ...value, updatedAt: /* @__PURE__ */ new Date() };
+      const updateValue = {
+        updatedAt: /* @__PURE__ */ new Date()
+      };
+      if (value.name !== void 0) {
+        updateValue.name = value.name;
+      }
+      if (value.type !== void 0) {
+        updateValue.type = value.type;
+      }
+      if (value.set !== void 0) {
+        updateValue.set = value.set;
+      }
+      if (value.units && Array.isArray(value.units)) {
+        updateValue.units = value.units.map((item) => {
+          try {
+            return {
+              ...item,
+              unit: new import_mongodb2.ObjectId(item.unit)
+            };
+          } catch (error) {
+            throw new import_node_server_utils2.BadRequestError(`Invalid unit ID format: ${item.unit}`);
+          }
+        });
+      }
       const res = await collection.updateOne({ _id }, { $set: updateValue });
       if (res.modifiedCount === 0) {
         throw new import_node_server_utils2.InternalServerError("Unable to update cleaning area.");
@@ -392,17 +392,15 @@ function useAreaRepository() {
     } catch (error) {
       throw new import_node_server_utils2.BadRequestError("Invalid area ID format.");
     }
-    if (value.checklist && Array.isArray(value.checklist)) {
-      value.checklist = value.checklist.map((item) => {
+    if (value.units && Array.isArray(value.units)) {
+      value.units = value.units.map((item) => {
         try {
           return {
             ...item,
-            _id: new import_mongodb2.ObjectId(item._id)
+            unit: new import_mongodb2.ObjectId(item.unit)
           };
         } catch (error) {
-          throw new import_node_server_utils2.BadRequestError(
-            `Invalid checklist item ID format: ${item._id}`
-          );
+          throw new import_node_server_utils2.BadRequestError(`Invalid unit ID format: ${item.unit}`);
         }
       });
     }
@@ -464,8 +462,8 @@ function useAreaRepository() {
     createUniqueIndex,
     createArea,
     getAreas,
+    getAreasForChecklist,
     getAreaById,
-    getAreaByName,
     updateArea,
     updateAreaChecklist,
     deleteArea
@@ -475,10 +473,9 @@ function useAreaRepository() {
 // src/services/hygiene-area.service.ts
 var import_node_server_utils3 = require("@iservice365/node-server-utils");
 function useAreaService() {
-  const { createArea: _createArea } = useAreaRepository();
-  async function uploadByFile({
+  const { createArea: _createArea } = useAreaRepo();
+  async function importArea({
     dataJson,
-    createdBy,
     site
   }) {
     let dataArray;
@@ -490,49 +487,101 @@ function useAreaService() {
     if (!dataArray || dataArray.length === 0) {
       throw new import_node_server_utils3.NotFoundError("No data found in the uploaded file");
     }
-    const session = import_node_server_utils3.useAtlas.getClient()?.startSession();
     const insertedAreaIds = [];
-    try {
-      session?.startTransaction();
-      for (const row of dataArray) {
-        if (!row?.AREA_NAME) {
-          import_node_server_utils3.logger.warn("Skipping row with missing AREA_NAME:", row);
+    const duplicateAreas = [];
+    const failedAreas = [];
+    const skippedRows = [];
+    try {
+      for (let i = 0; i < dataArray.length; i++) {
+        const row = dataArray[i];
+        if (!row?.TYPE) {
+          import_node_server_utils3.logger.warn(`Skipping row ${i + 1} with missing TYPE:`, row);
+          skippedRows.push(i + 1);
+          continue;
+        }
+        const areaType = String(row.TYPE).trim();
+        if (!areaType) {
+          import_node_server_utils3.logger.warn(`Skipping row ${i + 1} with empty area type`);
+          skippedRows.push(i + 1);
+          continue;
+        }
+        if (!row?.NAME) {
+          import_node_server_utils3.logger.warn(`Skipping row ${i + 1} with missing NAME:`, row);
+          skippedRows.push(i + 1);
+          continue;
+        }
+        const areaName = String(row.NAME).trim();
+        if (!areaName) {
+          import_node_server_utils3.logger.warn(`Skipping row ${i + 1} with empty ${areaType} area name`);
+          skippedRows.push(i + 1);
           continue;
         }
         try {
-          const insertedId = await _createArea(
-            {
-              name: String(row.AREA_NAME).trim(),
-              site,
-              createdBy
-            },
-            session
-          );
+          const insertedId = await _createArea({
+            type: areaType,
+            name: areaName,
+            site
+          });
           insertedAreaIds.push(insertedId);
+          import_node_server_utils3.logger.info(`Successfully created ${areaType} area: ${areaName}`);
         } catch (error) {
           import_node_server_utils3.logger.error(
-            `Error creating area "${row.AREA_NAME}":`,
-            error.message
+            `Error creating ${areaType} area "${areaName}": ${error.message}`
           );
-          continue;
+          if (error.message.includes("duplicate")) {
+            duplicateAreas.push(areaName);
+          } else {
+            failedAreas.push(areaName);
+          }
         }
       }
-      await session?.commitTransaction();
-      import_node_server_utils3.logger.info(`Successfully uploaded ${insertedAreaIds.length} areas`);
-      return {
-        message: `Successfully uploaded ${insertedAreaIds.length} areas`
-      };
+      let message = `Upload completed: ${insertedAreaIds.length} areas successfully created`;
+      if (duplicateAreas.length > 0) {
+        message += `, ${duplicateAreas.length} areas skipped (already exist)`;
+      }
+      if (failedAreas.length > 0) {
+        message += `, ${failedAreas.length} areas failed`;
+      }
+      if (skippedRows.length > 0) {
+        message += `, ${skippedRows.length} rows skipped (invalid data)`;
+      }
+      import_node_server_utils3.logger.info(message);
+      if (insertedAreaIds.length === 0) {
+        if (duplicateAreas.length > 0 && failedAreas.length === 0) {
+          throw new import_node_server_utils3.BadRequestError(
+            `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_utils3.BadRequestError(
+            `No areas were created. Please check your data format and ensure area names are valid.`
+          );
+        } else if (skippedRows.length > 0) {
+          throw new import_node_server_utils3.BadRequestError(
+            `No areas were created. All rows contained invalid or missing area names.`
+          );
+        }
+      }
+      return { message };
     } catch (error) {
-      await session?.abortTransaction();
       import_node_server_utils3.logger.error("Error while uploading area information", error);
-      throw error;
-    } finally {
-      session?.endSession();
+      if (error instanceof import_node_server_utils3.BadRequestError) {
+        throw error;
+      } else if (error.message.includes("duplicate")) {
+        throw new import_node_server_utils3.BadRequestError(
+          `Upload failed due to duplicate area names. Please ensure all area names are unique.`
+        );
+      } else if (error.message.includes("validation")) {
+        throw new import_node_server_utils3.BadRequestError(
+          "Upload failed due to invalid data format. Please check that all required fields are properly filled."
+        );
+      } else {
+        throw new import_node_server_utils3.BadRequestError(
+          `Upload failed: ${error.message || "Please check your data format and try again."}`
+        );
+      }
     }
   }
-  return {
-    uploadByFile
-  };
+  return { importArea };
 }
 
 // src/controllers/hygiene-area.controller.ts
@@ -570,20 +619,15 @@ function convertBufferFile(bufferFile) {
 function useAreaController() {
   const {
     createArea: _createArea,
-    getAreas: _getAll,
+    getAreas: _getAreas,
     getAreaById: _getAreaById,
     updateArea: _updateArea,
     updateAreaChecklist: _updateAreaChecklist,
     deleteArea: _deleteById
-  } = useAreaRepository();
-  const { uploadByFile: _uploadByFile } = useAreaService();
+  } = useAreaRepo();
+  const { importArea: _importArea } = useAreaService();
   async function createArea(req, res, next) {
-    const cookies = req.headers.cookie ? req.headers.cookie.split(";").map((cookie) => cookie.trim().split("=")).reduce(
-      (acc, [key, value]) => ({ ...acc, [key]: value }),
-      {}
-    ) : {};
-    const createdBy = cookies["user"] || "";
-    const payload = { ...req.body, createdBy };
+    const payload = { ...req.body, ...req.params };
     const { error } = areaSchema.validate(payload);
     if (error) {
       import_node_server_utils4.logger.log({ level: "error", message: error.message });
@@ -600,35 +644,30 @@ function useAreaController() {
       return;
     }
   }
-  async function getAll(req, res, next) {
-    const query = req.query;
+  async function getAreas(req, res, next) {
+    const query = { ...req.query, ...req.params };
     const validation = import_joi2.default.object({
       page: import_joi2.default.number().min(1).optional().allow("", null),
       limit: import_joi2.default.number().min(1).optional().allow("", null),
       search: import_joi2.default.string().optional().allow("", null),
-      startDate: import_joi2.default.alternatives().try(import_joi2.default.date(), import_joi2.default.string()).optional().allow("", null),
-      endDate: import_joi2.default.alternatives().try(import_joi2.default.date(), import_joi2.default.string()).optional().allow("", null),
-      site: import_joi2.default.string().hex().optional().allow("", null)
+      site: import_joi2.default.string().hex().required()
     });
     const { error } = validation.validate(query);
     if (error) {
+      import_node_server_utils4.logger.log({ level: "error", message: error.message });
       next(new import_node_server_utils4.BadRequestError(error.message));
       return;
     }
     const page = parseInt(req.query.page) ?? 1;
     const limit = parseInt(req.query.limit) ?? 20;
     const search = req.query.search ?? "";
-    const site = req.query.site ?? "";
-    const startDate = req.query.startDate ?? "";
-    const endDate = req.query.endDate ?? "";
+    const site = req.params.site ?? "";
     try {
-      const data = await _getAll({
+      const data = await _getAreas({
         page,
         limit,
         search,
-        site,
-        startDate,
-        endDate
+        site
       });
       res.json(data);
       return;
@@ -660,7 +699,17 @@ function useAreaController() {
     const payload = { id: req.params.id, ...req.body };
     const schema = import_joi2.default.object({
       id: import_joi2.default.string().hex().required(),
-      name: import_joi2.default.string().required()
+      name: import_joi2.default.string().optional().allow("", null),
+      type: import_joi2.default.string().optional().allow("", null, ...allowedTypes),
+      set: import_joi2.default.number().min(0).optional(),
+      units: import_joi2.default.array().items(
+        import_joi2.default.object({
+          unit: import_joi2.default.string().hex().required(),
+          name: import_joi2.default.string().required()
+        }).required()
+      ).min(1).unique("unit", { ignoreUndefined: true }).optional().messages({
+        "array.unique": "Duplicate area units are not allowed"
+      })
     });
     const { error } = schema.validate(payload);
     if (error) {
@@ -683,13 +732,13 @@ function useAreaController() {
     const payload = { id: req.params.id, ...req.body };
     const schema = import_joi2.default.object({
       id: import_joi2.default.string().hex().required(),
-      checklist: import_joi2.default.array().items(
+      units: import_joi2.default.array().items(
         import_joi2.default.object({
-          _id: import_joi2.default.string().hex().required(),
+          unit: import_joi2.default.string().hex().required(),
           name: import_joi2.default.string().required()
         }).required()
-      ).min(1).unique("_id", { ignoreUndefined: true }).messages({
-        "array.unique": "Duplicate checklist items are not allowed"
+      ).min(1).unique("unit", { ignoreUndefined: true }).messages({
+        "array.unique": "Duplicate area units are not allowed"
       })
     });
     const { error } = schema.validate(payload);
@@ -711,10 +760,8 @@ function useAreaController() {
   }
   async function deleteArea(req, res, next) {
     const id = req.params.id;
-    const validation = import_joi2.default.object({
-      id: import_joi2.default.string().hex().required()
-    });
-    const { error } = validation.validate({ id });
+    const validation = import_joi2.default.string().hex().required();
+    const { error } = validation.validate(id);
     if (error) {
       import_node_server_utils4.logger.log({ level: "error", message: error.message });
       next(new import_node_server_utils4.BadRequestError(error.message));
@@ -730,22 +777,14 @@ function useAreaController() {
       return;
     }
   }
-  async function uploadByFile(req, res, next) {
+  async function importArea(req, res, next) {
     if (!req.file) {
       next(new import_node_server_utils4.BadRequestError("File is required!"));
       return;
     }
-    const cookies = req.headers.cookie ? req.headers.cookie.split(";").map((cookie) => cookie.trim().split("=")).reduce(
-      (acc, [key, value]) => ({ ...acc, [key]: value }),
-      {}
-    ) : {};
-    const createdBy = cookies["user"] || "";
-    const { site } = req.body;
-    const schema = import_joi2.default.object({
-      site: import_joi2.default.string().hex().optional().allow("", null),
-      createdBy: import_joi2.default.string().hex().required()
-    });
-    const { error } = schema.validate({ site, createdBy });
+    const { site } = req.params;
+    const schema = import_joi2.default.string().hex().required();
+    const { error } = schema.validate(site);
     if (error) {
       import_node_server_utils4.logger.log({ level: "error", message: error.message });
       next(new import_node_server_utils4.BadRequestError(error.message));
@@ -754,7 +793,7 @@ function useAreaController() {
     try {
       const xlsData = await convertBufferFile(req.file.buffer);
       const dataJson = JSON.stringify(xlsData);
-      const result = await _uploadByFile({ dataJson, createdBy, site });
+      const result = await _importArea({ dataJson, site });
       return res.status(201).json(result);
     } catch (error2) {
       import_node_server_utils4.logger.log({ level: "error", message: error2.message });
@@ -764,35 +803,27 @@ function useAreaController() {
   }
   return {
     createArea,
-    getAll,
+    getAreas,
     getAreaById,
     updateArea,
     updateAreaChecklist,
     deleteArea,
-    uploadByFile
+    importArea
   };
 }
 
-// src/models/hygiene-toilet-location.model.ts
+// src/models/hygiene-unit.model.ts
 var import_node_server_utils5 = require("@iservice365/node-server-utils");
 var import_joi3 = __toESM(require("joi"));
 var import_mongodb3 = require("mongodb");
-var toiletLocationSchema = import_joi3.default.object({
-  name: import_joi3.default.string().required(),
+var unitSchema = import_joi3.default.object({
   site: import_joi3.default.string().hex().required(),
-  createdBy: import_joi3.default.string().hex().required(),
-  checklist: import_joi3.default.array().items(
-    import_joi3.default.object({
-      _id: import_joi3.default.string().hex().required(),
-      name: import_joi3.default.string().required()
-    })
-  ).optional(),
-  updatedAt: import_joi3.default.date().optional().allow("", null),
-  status: import_joi3.default.string().allow("", null).optional()
+  name: import_joi3.default.string().required()
 });
-function MToiletLocation(value) {
-  const { error } = toiletLocationSchema.validate(value);
+function MUnit(value) {
+  const { error } = unitSchema.validate(value);
   if (error) {
+    import_node_server_utils5.logger.info(`Hygiene Unit Model: ${error.message}`);
     throw new import_node_server_utils5.BadRequestError(error.message);
   }
   if (value.site) {
@@ -802,75 +833,64 @@ function MToiletLocation(value) {
       throw new import_node_server_utils5.BadRequestError("Invalid site ID format.");
     }
   }
-  if (value.createdBy) {
-    try {
-      value.createdBy = new import_mongodb3.ObjectId(value.createdBy);
-    } catch (error2) {
-      throw new import_node_server_utils5.BadRequestError("Invalid createdBy ID format.");
-    }
-  }
-  if (value.checklist && Array.isArray(value.checklist)) {
-    value.checklist = value.checklist.map((item) => {
-      try {
-        return {
-          ...item,
-          _id: new import_mongodb3.ObjectId(item._id)
-        };
-      } catch (error2) {
-        throw new import_node_server_utils5.BadRequestError(
-          `Invalid checklist item ID format: ${item._id}`
-        );
-      }
-    });
-  }
   return {
-    name: value.name,
     site: value.site,
-    createdBy: value.createdBy,
-    checklist: value.checklist,
-    status: value.status ?? "",
+    name: value.name,
     createdAt: /* @__PURE__ */ new Date(),
-    updatedAt: value.updatedAt ?? "",
-    deletedAt: value.deletedAt ?? ""
+    status: "active",
+    updatedAt: "",
+    deletedAt: ""
   };
 }
 
-// src/repositories/hygiene-toilet-location.repository.ts
+// src/services/hygiene-unit.service.ts
+var import_node_server_utils7 = require("@iservice365/node-server-utils");
+
+// src/repositories/hygiene-unit.repository.ts
 var import_mongodb4 = require("mongodb");
 var import_node_server_utils6 = require("@iservice365/node-server-utils");
-function useToiletLocationRepository() {
+function useUnitRepository() {
   const db = import_node_server_utils6.useAtlas.getDb();
   if (!db) {
     throw new import_node_server_utils6.InternalServerError("Unable to connect to server.");
   }
-  const namespace_collection = "hygiene-toilet-locations";
+  const namespace_collection = "site.cleaning.area.unit";
   const collection = db.collection(namespace_collection);
-  const { delNamespace, setCache, getCache, delCache } = (0, import_node_server_utils6.useCache)(namespace_collection);
-  async function createIndexes() {
+  const { delNamespace, setCache, getCache } = (0, import_node_server_utils6.useCache)(namespace_collection);
+  async function createIndex() {
     try {
       await collection.createIndexes([
         { key: { site: 1 } },
-        { key: { name: "text" } }
+        { key: { status: 1 } }
       ]);
     } catch (error) {
-      throw new import_node_server_utils6.InternalServerError("Failed to create index on site.");
+      throw new import_node_server_utils6.InternalServerError("Failed to create index on hygiene unit.");
+    }
+  }
+  async function createTextIndex() {
+    try {
+      await collection.createIndex({ name: "text" });
+    } catch (error) {
+      throw new import_node_server_utils6.InternalServerError(
+        "Failed to create text index on hygiene unit."
+      );
     }
   }
   async function createUniqueIndex() {
     try {
       await collection.createIndex(
-        { name: 1, site: 1, deletedAt: 1 },
+        { site: 1, name: 1, deletedAt: 1 },
         { unique: true }
       );
     } catch (error) {
       throw new import_node_server_utils6.InternalServerError(
-        "Failed to create unique index on hygiene area."
+        "Failed to create unique index on hygiene unit."
       );
     }
   }
-  async function create(value, session) {
+  async function createUnit(value, session) {
     try {
-      value = MToiletLocation(value);
+      value = MUnit(value);
       const res = await collection.insertOne(value, { session });
       delNamespace().then(() => {
         import_node_server_utils6.logger.info(`Cache cleared for namespace: ${namespace_collection}`);
@@ -884,190 +904,46 @@ function useToiletLocationRepository() {
     } catch (error) {
       const isDuplicated = error.message.includes("duplicate");
       if (isDuplicated) {
-        throw new import_node_server_utils6.BadRequestError("Toilet location already exists.");
+        throw new import_node_server_utils6.BadRequestError("Unit already exists.");
       }
       throw error;
     }
   }
-  async function updateToiletLocation(_id, value) {
+  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 {
-      _id = new import_mongodb4.ObjectId(_id);
+      site = new import_mongodb4.ObjectId(site);
+      query.site = site;
+      cacheOptions.site = site.toString();
     } catch (error) {
-      throw new import_node_server_utils6.BadRequestError("Invalid area ID format.");
-    }
-    if (value.checklist && Array.isArray(value.checklist)) {
-      value.checklist = value.checklist.map((item) => {
-        try {
-          return {
-            ...item,
-            _id: new import_mongodb4.ObjectId(item._id)
-          };
-        } catch (error) {
-          throw new import_node_server_utils6.BadRequestError(
-            `Invalid checklist item ID format: ${item._id}`
-          );
-        }
-      });
+      throw new import_node_server_utils6.BadRequestError("Invalid site ID format.");
     }
-    try {
-      const updateValue = { ...value, updatedAt: /* @__PURE__ */ new Date() };
-      const res = await collection.updateOne({ _id }, { $set: updateValue });
-      if (res.modifiedCount === 0) {
-        throw new import_node_server_utils6.InternalServerError("Unable to update toilet location.");
-      }
-      delNamespace().then(() => {
-        import_node_server_utils6.logger.info(`Cache cleared for namespace: ${namespace_collection}`);
-      }).catch((err) => {
-        import_node_server_utils6.logger.error(
-          `Failed to clear cache for namespace: ${namespace_collection}`,
-          err
-        );
-      });
-      return res.modifiedCount;
-    } catch (error) {
-      const isDuplicated = error.message.includes("duplicate");
-      if (isDuplicated) {
-        throw new import_node_server_utils6.BadRequestError("Toilet location already exists.");
-      }
-      throw error;
-    }
-  }
-  async function deleteToiletLocation(_id, session) {
-    try {
-      _id = new import_mongodb4.ObjectId(_id);
-    } catch (error) {
-      throw new import_node_server_utils6.BadRequestError("Invalid area ID format.");
-    }
-    try {
-      const updateValue = {
-        status: "deleted",
-        updatedAt: /* @__PURE__ */ new Date(),
-        deletedAt: /* @__PURE__ */ new Date()
-      };
-      const res = await collection.updateOne(
-        { _id },
-        { $set: updateValue },
-        { session }
-      );
-      if (res.modifiedCount === 0) {
-        throw new import_node_server_utils6.InternalServerError("Unable to delete toilet location.");
-      }
-      delNamespace().then(() => {
-        import_node_server_utils6.logger.info(`Cache cleared for namespace: ${namespace_collection}`);
-      }).catch((err) => {
-        import_node_server_utils6.logger.error(
-          `Failed to clear cache for namespace: ${namespace_collection}`,
-          err
-        );
-      });
-      return res.modifiedCount;
-    } catch (error) {
-      throw error;
-    }
-  }
-  async function getToiletLocations({
-    page = 1,
-    limit = 10,
-    search = "",
-    sort = {},
-    startDate = "",
-    endDate = "",
-    site = ""
-  }) {
-    page = page > 0 ? page - 1 : 0;
-    let dateFilter = {};
-    try {
-      site = new import_mongodb4.ObjectId(site);
-    } catch (error) {
-      throw new import_node_server_utils6.BadRequestError("Invalid site ID format.");
-    }
-    const query = {
-      status: { $ne: "deleted" }
-    };
-    const cacheOptions = {
-      site: site.toString()
-    };
-    sort = Object.keys(sort).length > 0 ? sort : { _id: -1 };
-    cacheOptions.sort = JSON.stringify(sort);
     if (search) {
       query.$or = [{ name: { $regex: search, $options: "i" } }];
       cacheOptions.search = search;
     }
-    delNamespace().then(() => {
-      import_node_server_utils6.logger.info(`Cache cleared for namespace: ${namespace_collection}`);
-    }).catch((err) => {
-      import_node_server_utils6.logger.error(
-        `Failed to clear cache for namespace: ${namespace_collection}`,
-        err
-      );
-    });
     const cacheKey = (0, import_node_server_utils6.makeCacheKey)(namespace_collection, cacheOptions);
     const cachedData = await getCache(cacheKey);
     if (cachedData) {
       import_node_server_utils6.logger.info(`Cache hit for key: ${cacheKey}`);
       return cachedData;
     }
-    if (startDate && endDate) {
-      dateFilter = {
-        createdAt: {
-          $gte: new Date(startDate),
-          $lte: new Date(endDate)
-        }
-      };
-    } else if (startDate) {
-      dateFilter = { createdAt: { $gte: new Date(startDate) } };
-    } else if (endDate) {
-      dateFilter = { createdAt: { $lte: new Date(endDate) } };
-    }
     try {
       const items = await collection.aggregate([
-        {
-          $match: {
-            ...dateFilter,
-            ...query
-          }
-        },
-        {
-          $lookup: {
-            from: "sites",
-            localField: "site",
-            foreignField: "_id",
-            pipeline: [{ $project: { name: 1 } }],
-            as: "site"
-          }
-        },
-        {
-          $unwind: {
-            path: "$site",
-            preserveNullAndEmptyArrays: true
-          }
-        },
-        {
-          $lookup: {
-            from: "users",
-            localField: "createdBy",
-            foreignField: "_id",
-            pipeline: [{ $project: { name: 1 } }],
-            as: "createdBy"
-          }
-        },
-        {
-          $unwind: {
-            path: "$createdBy",
-            preserveNullAndEmptyArrays: true
-          }
-        },
-        {
-          $project: {
-            name: 1,
-            site: "$site._id",
-            siteName: "$site.name",
-            createdByName: "$createdBy.name",
-            checklist: 1,
-            status: 1,
-            createdAt: 1
-          }
-        },
+        { $match: query },
+        { $project: { name: 1 } },
         { $sort: { _id: -1 } },
         { $skip: page * limit },
         { $limit: limit }
@@ -1084,47 +960,17 @@ function useToiletLocationRepository() {
       throw error;
     }
   }
-  async function getToiletLocationByName(name, site) {
-    try {
-      if (site)
-        site = new import_mongodb4.ObjectId(site);
-    } catch (error) {
-      throw new import_node_server_utils6.BadRequestError("Invalid site ID format.");
-    }
-    try {
-      return await collection.findOne({
-        name: { $regex: new RegExp(`^${name}$`, "i") },
-        ...site && { site }
-      });
-    } catch (error) {
-      throw new import_node_server_utils6.BadRequestError("Unable to fetch toilet location by name.");
-    }
-  }
-  async function updateToiletLocationChecklist(_id, value) {
+  async function updateUnit(_id, value) {
     try {
       _id = new import_mongodb4.ObjectId(_id);
     } catch (error) {
-      throw new import_node_server_utils6.BadRequestError("Invalid area ID format.");
-    }
-    if (value.checklist && Array.isArray(value.checklist)) {
-      value.checklist = value.checklist.map((item) => {
-        try {
-          return {
-            ...item,
-            _id: new import_mongodb4.ObjectId(item._id)
-          };
-        } catch (error) {
-          throw new import_node_server_utils6.BadRequestError(
-            `Invalid checklist item ID format: ${item._id}`
-          );
-        }
-      });
+      throw new import_node_server_utils6.BadRequestError("Invalid unit ID format.");
     }
     try {
       const updateValue = { ...value, updatedAt: /* @__PURE__ */ new Date() };
       const res = await collection.updateOne({ _id }, { $set: updateValue });
       if (res.modifiedCount === 0) {
-        throw new import_node_server_utils6.InternalServerError("Unable to update toilet location.");
+        throw new import_node_server_utils6.InternalServerError("Unable to update cleaning unit.");
       }
       delNamespace().then(() => {
         import_node_server_utils6.logger.info(`Cache cleared for namespace: ${namespace_collection}`);
@@ -1136,70 +982,62 @@ function useToiletLocationRepository() {
       });
       return res.modifiedCount;
     } catch (error) {
+      const isDuplicated = error.message.includes("duplicate");
+      if (isDuplicated) {
+        throw new import_node_server_utils6.BadRequestError("Area already exists.");
+      }
       throw error;
     }
   }
-  async function getToiletLocationById(_id) {
+  async function deleteUnit(_id, session) {
     try {
       _id = new import_mongodb4.ObjectId(_id);
     } catch (error) {
-      throw new import_node_server_utils6.BadRequestError("Invalid area ID format.");
-    }
-    const query = {
-      _id,
-      status: { $ne: "deleted" }
-    };
-    const cacheKey = (0, import_node_server_utils6.makeCacheKey)(namespace_collection, {
-      _id: _id.toString()
-    });
-    const cachedData = await getCache(cacheKey);
-    if (cachedData) {
-      import_node_server_utils6.logger.info(`Cache hit for key: ${cacheKey}`);
-      return cachedData;
+      throw new import_node_server_utils6.BadRequestError("Invalid unit ID format.");
     }
     try {
-      const data = await collection.aggregate([
-        { $match: query },
-        {
-          $project: {
-            name: 1,
-            checklist: 1
-          }
-        }
-      ]).toArray();
-      if (!data || !data.length) {
-        throw new import_node_server_utils6.NotFoundError("Area not found.");
+      const updateValue = {
+        status: "deleted",
+        updatedAt: /* @__PURE__ */ new Date(),
+        deletedAt: /* @__PURE__ */ new Date()
+      };
+      const res = await collection.updateOne(
+        { _id },
+        { $set: updateValue },
+        { session }
+      );
+      if (res.modifiedCount === 0) {
+        throw new import_node_server_utils6.InternalServerError("Unable to delete unit.");
       }
-      setCache(cacheKey, data[0], 15 * 60).then(() => {
-        import_node_server_utils6.logger.info(`Cache set for key: ${cacheKey}`);
+      delNamespace().then(() => {
+        import_node_server_utils6.logger.info(`Cache cleared for namespace: ${namespace_collection}`);
       }).catch((err) => {
-        import_node_server_utils6.logger.error(`Failed to set cache for key: ${cacheKey}`, err);
+        import_node_server_utils6.logger.error(
+          `Failed to clear cache for namespace: ${namespace_collection}`,
+          err
+        );
       });
-      return data[0];
+      return res.modifiedCount;
     } catch (error) {
       throw error;
     }
   }
   return {
-    createIndexes,
+    createIndex,
+    createTextIndex,
     createUniqueIndex,
-    getToiletLocations,
-    create,
-    updateToiletLocation,
-    deleteToiletLocation,
-    getToiletLocationByName,
-    getToiletLocationById,
-    updateToiletLocationChecklist
+    createUnit,
+    getUnits,
+    updateUnit,
+    deleteUnit
   };
 }
 
-// src/services/hygiene-toilet-location.service.ts
-var import_node_server_utils7 = require("@iservice365/node-server-utils");
-function useToiletLocationService() {
-  const { create: _createToilet } = useToiletLocationRepository();
-  async function uploadByFile({
+// src/services/hygiene-unit.service.ts
+function useUnitService() {
+  const { createUnit: _createUnit } = useUnitRepository();
+  async function importUnit({
     dataJson,
-    createdBy,
     site
   }) {
     let dataArray;
@@ -1211,146 +1049,158 @@ function useToiletLocationService() {
     if (!dataArray || dataArray.length === 0) {
       throw new import_node_server_utils7.NotFoundError("No data found in the uploaded file");
     }
-    const session = import_node_server_utils7.useAtlas.getClient()?.startSession();
-    const insertedAreaIds = [];
-    try {
-      session?.startTransaction();
-      for (const row of dataArray) {
-        if (!row?.AREA_NAME) {
-          import_node_server_utils7.logger.warn("Skipping row with missing TOILET NAME:", row);
+    const insertedUnitIds = [];
+    const duplicateUnits = [];
+    const failedUnits = [];
+    const skippedRows = [];
+    try {
+      for (let i = 0; i < dataArray.length; i++) {
+        const row = dataArray[i];
+        if (!row?.NAME) {
+          import_node_server_utils7.logger.warn(`Skipping row ${i + 1} with missing NAME:`, row);
+          skippedRows.push(i + 1);
+          continue;
+        }
+        const unitName = String(row.NAME).trim();
+        if (!unitName) {
+          import_node_server_utils7.logger.warn(`Skipping row ${i + 1} with empty unit name`);
+          skippedRows.push(i + 1);
           continue;
         }
         try {
-          const insertedId = await _createToilet(
-            {
-              name: String(row.TOILET_NAME).trim(),
-              site,
-              createdBy
-            },
-            session
-          );
-          insertedAreaIds.push(insertedId);
+          const insertedId = await _createUnit({
+            name: unitName,
+            site
+          });
+          insertedUnitIds.push(insertedId);
+          import_node_server_utils7.logger.info(`Successfully created unit: ${unitName}`);
         } catch (error) {
-          import_node_server_utils7.logger.error(
-            `Error creating area "${row.AREA_NAME}":`,
-            error.message
+          import_node_server_utils7.logger.error(`Error creating unit "${unitName}": ${error.message}`);
+          if (error.message.includes("Unit already exists")) {
+            duplicateUnits.push(unitName);
+          } else {
+            failedUnits.push(unitName);
+          }
+        }
+      }
+      let message = `Upload completed: ${insertedUnitIds.length} units successfully created`;
+      if (duplicateUnits.length > 0) {
+        message += `, ${duplicateUnits.length} units skipped (already exist)`;
+      }
+      if (failedUnits.length > 0) {
+        message += `, ${failedUnits.length} units failed`;
+      }
+      if (skippedRows.length > 0) {
+        message += `, ${skippedRows.length} rows skipped (invalid data)`;
+      }
+      import_node_server_utils7.logger.info(message);
+      if (insertedUnitIds.length === 0) {
+        if (duplicateUnits.length > 0 && failedUnits.length === 0) {
+          throw new import_node_server_utils7.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_utils7.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_utils7.BadRequestError(
+            `No units were created. All rows contained invalid or missing unit names.`
           );
-          continue;
         }
       }
-      await session?.commitTransaction();
-      import_node_server_utils7.logger.info(`Successfully uploaded ${insertedAreaIds.length} areas`);
-      return {
-        message: `Successfully uploaded ${insertedAreaIds.length} areas`
-      };
-    } catch (error) {
-      await session?.abortTransaction();
-      import_node_server_utils7.logger.error("Error while uploading area information", error);
-      throw error;
-    } finally {
-      session?.endSession();
+      return { message };
+    } catch (error) {
+      import_node_server_utils7.logger.error("Error while uploading unit information", error);
+      if (error instanceof import_node_server_utils7.BadRequestError) {
+        throw error;
+      } else if (error.message.includes("duplicate")) {
+        throw new import_node_server_utils7.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_utils7.BadRequestError(
+          "Upload failed due to invalid data format. Please check that all required fields are properly filled."
+        );
+      } else {
+        throw new import_node_server_utils7.BadRequestError(
+          `Upload failed: ${error.message || "Please check your data format and try again."}`
+        );
+      }
     }
   }
-  return {
-    uploadByFile
-  };
+  return { importUnit };
 }
 
-// src/controllers/hygiene-toilet-location.controller.ts
-var import_joi4 = __toESM(require("joi"));
+// src/controllers/hygiene-unit.controller.ts
 var import_node_server_utils8 = require("@iservice365/node-server-utils");
-function useToiletLocationController() {
-  const { uploadByFile: _uploadByFile } = useToiletLocationService();
+var import_joi4 = __toESM(require("joi"));
+function useUnitController() {
   const {
-    create: _createToiletLocation,
-    updateToiletLocation: _updateToiletLocation,
-    updateToiletLocationChecklist: _updateToiletLocationChecklist,
-    getToiletLocationById: _getToiletLocationById,
-    getToiletLocations: _getAll,
-    deleteToiletLocation: _deleteById
-  } = useToiletLocationRepository();
-  async function getAll(req, res, next) {
-    const query = req.query;
+    createUnit: _createUnit,
+    getUnits: _getUnits,
+    updateUnit: _updateUnit,
+    deleteUnit: _deleteUnit
+  } = useUnitRepository();
+  const { importUnit: _importUnit } = useUnitService();
+  async function createUnit(req, res, next) {
+    const payload = { ...req.body, ...req.params };
+    const { error } = unitSchema.validate(payload);
+    if (error) {
+      import_node_server_utils8.logger.log({ level: "error", message: error.message });
+      next(new import_node_server_utils8.BadRequestError(error.message));
+      return;
+    }
+    try {
+      const id = await _createUnit(payload);
+      res.status(201).json({ message: "Unit created successfully.", id });
+      return;
+    } catch (error2) {
+      import_node_server_utils8.logger.log({ level: "error", message: error2.message });
+      next(error2);
+      return;
+    }
+  }
+  async function getUnits(req, res, next) {
+    const query = { ...req.query, ...req.params };
     const validation = import_joi4.default.object({
       page: import_joi4.default.number().min(1).optional().allow("", null),
       limit: import_joi4.default.number().min(1).optional().allow("", null),
       search: import_joi4.default.string().optional().allow("", null),
-      site: import_joi4.default.string().hex().optional().allow("", null)
+      site: import_joi4.default.string().hex().required()
     });
     const { error } = validation.validate(query);
     if (error) {
+      import_node_server_utils8.logger.log({ level: "error", message: error.message });
       next(new import_node_server_utils8.BadRequestError(error.message));
       return;
     }
     const page = parseInt(req.query.page) ?? 1;
-    let limit = parseInt(req.query.limit) ?? 20;
-    limit = isNaN(limit) ? 20 : limit;
-    const sort = req.query.sort ? String(req.query.sort).split(",") : "";
-    const sortOrder = req.query.sortOrder ? String(req.query.sortOrder).split(",") : "";
-    const sortObj = {};
-    if (sort && Array.isArray(sort) && sort.length && sortOrder && Array.isArray(sortOrder) && sortOrder.length) {
-      sort.forEach((field, index) => {
-        sortObj[field] = sortOrder[index] === "desc" ? -1 : 1;
-      });
-    }
-    const site = req.query.site ?? "";
+    const limit = parseInt(req.query.limit) ?? 20;
     const search = req.query.search ?? "";
+    const site = req.params.site ?? "";
     try {
-      const buildings = await _getAll({
+      const data = await _getUnits({
         page,
         limit,
-        sort: sortObj,
-        site,
-        search
+        search,
+        site
       });
-      res.json(buildings);
+      res.json(data);
       return;
     } catch (error2) {
+      import_node_server_utils8.logger.log({ level: "error", message: error2.message });
       next(error2);
-    }
-  }
-  async function createToiletLocation(req, res, next) {
-    const cookies = req.headers.cookie ? req.headers.cookie.split(";").map((cookie) => cookie.trim().split("=")).reduce(
-      (acc, [key, value]) => ({ ...acc, [key]: value }),
-      {}
-    ) : {};
-    const createdBy = cookies["user"] || "";
-    const payload = { ...req.body, createdBy };
-    const schema = import_joi4.default.object({
-      name: import_joi4.default.string().required(),
-      site: import_joi4.default.string().hex().optional().allow("", null),
-      status: import_joi4.default.string().optional().allow("", null),
-      createdBy: import_joi4.default.string().hex().optional().allow("", null)
-    });
-    const { error } = schema.validate(payload);
-    if (error) {
-      next(new import_node_server_utils8.BadRequestError(error.message));
-      import_node_server_utils8.logger.info(`Controller: ${error.message}`);
-      return;
-    }
-    try {
-      const result = await _createToiletLocation(payload);
-      res.status(201).json(result);
       return;
-    } catch (error2) {
-      next(error2);
     }
   }
-  async function updateToiletLocation(req, res, next) {
+  async function updateUnit(req, res, next) {
     const payload = { id: req.params.id, ...req.body };
-    const schema = import_joi4.default.object({
+    const validation = import_joi4.default.object({
       id: import_joi4.default.string().hex().required(),
-      name: import_joi4.default.string().required(),
-      checklist: import_joi4.default.array().items(
-        import_joi4.default.object({
-          _id: import_joi4.default.string().hex().required(),
-          name: import_joi4.default.string().required()
-        }).optional()
-      ),
-      site: import_joi4.default.string().hex().optional().allow("", null),
-      status: import_joi4.default.string().optional().allow("", null)
+      name: import_joi4.default.string().required()
     });
-    const { error } = schema.validate(payload);
+    const { error } = validation.validate(payload);
     if (error) {
       import_node_server_utils8.logger.log({ level: "error", message: error.message });
       next(new import_node_server_utils8.BadRequestError(error.message));
@@ -1358,74 +1208,29 @@ function useToiletLocationController() {
     }
     try {
       const { id, ...value } = payload;
-      await _updateToiletLocation(id, value);
-      res.status(201).json({ message: "Toilet location updated successfully." });
+      await _updateUnit(id, value);
+      res.json({ message: "Unit updated successfully." });
       return;
     } catch (error2) {
       import_node_server_utils8.logger.log({ level: "error", message: error2.message });
       next(error2);
+      return;
     }
   }
-  async function deleteToiletLocation(req, res, next) {
+  async function deleteUnit(req, res, next) {
     const id = req.params.id;
     const validation = import_joi4.default.object({
       id: import_joi4.default.string().hex().required()
     });
     const { error } = validation.validate({ id });
-    if (error) {
-      next(new import_node_server_utils8.BadRequestError(error.message));
-      return;
-    }
-    try {
-      const message = await _deleteById(id);
-      res.json(message);
-      return;
-    } catch (error2) {
-      next(error2);
-    }
-  }
-  async function updateToiletLocationChecklist(req, res, next) {
-    const payload = { id: req.params.id, ...req.body };
-    const schema = import_joi4.default.object({
-      id: import_joi4.default.string().hex().required(),
-      checklist: import_joi4.default.array().items(
-        import_joi4.default.object({
-          _id: import_joi4.default.string().hex().required(),
-          name: import_joi4.default.string().required()
-        }).required()
-      ).min(1).unique("_id", { ignoreUndefined: true }).messages({
-        "array.unique": "Duplicate checklist items are not allowed"
-      })
-    });
-    const { error } = schema.validate(payload);
-    if (error) {
-      import_node_server_utils8.logger.log({ level: "error", message: error.message });
-      next(new import_node_server_utils8.BadRequestError(error.message));
-      return;
-    }
-    try {
-      const { id, ...value } = payload;
-      await _updateToiletLocationChecklist(id, value);
-      res.json({ message: "Toilet location updated successfully." });
-      return;
-    } catch (error2) {
-      import_node_server_utils8.logger.log({ level: "error", message: error2.message });
-      next(error2);
-      return;
-    }
-  }
-  async function getToiletLocationById(req, res, next) {
-    const validation = import_joi4.default.string().hex().required();
-    const _id = req.params.id;
-    const { error } = validation.validate(_id);
     if (error) {
       import_node_server_utils8.logger.log({ level: "error", message: error.message });
       next(new import_node_server_utils8.BadRequestError(error.message));
       return;
     }
     try {
-      const data = await _getToiletLocationById(_id);
-      res.json(data);
+      await _deleteUnit(id);
+      res.json({ message: "Unit deleted successfully." });
       return;
     } catch (error2) {
       import_node_server_utils8.logger.log({ level: "error", message: error2.message });
@@ -1433,22 +1238,14 @@ function useToiletLocationController() {
       return;
     }
   }
-  async function uploadByFile(req, res, next) {
+  async function importUnit(req, res, next) {
     if (!req.file) {
       next(new import_node_server_utils8.BadRequestError("File is required!"));
       return;
     }
-    const cookies = req.headers.cookie ? req.headers.cookie.split(";").map((cookie) => cookie.trim().split("=")).reduce(
-      (acc, [key, value]) => ({ ...acc, [key]: value }),
-      {}
-    ) : {};
-    const createdBy = cookies["user"] || "";
-    const { site } = req.body;
-    const schema = import_joi4.default.object({
-      site: import_joi4.default.string().hex().optional().allow("", null),
-      createdBy: import_joi4.default.string().hex().required()
-    });
-    const { error } = schema.validate({ site, createdBy });
+    const { site } = req.params;
+    const validation = import_joi4.default.string().hex().required();
+    const { error } = validation.validate(site);
     if (error) {
       import_node_server_utils8.logger.log({ level: "error", message: error.message });
       next(new import_node_server_utils8.BadRequestError(error.message));
@@ -1457,7 +1254,7 @@ function useToiletLocationController() {
     try {
       const xlsData = await convertBufferFile(req.file.buffer);
       const dataJson = JSON.stringify(xlsData);
-      const result = await _uploadByFile({ dataJson, createdBy, site });
+      const result = await _importUnit({ dataJson, site });
       return res.status(201).json(result);
     } catch (error2) {
       import_node_server_utils8.logger.log({ level: "error", message: error2.message });
@@ -1466,13 +1263,11 @@ function useToiletLocationController() {
     }
   }
   return {
-    getAll,
-    createToiletLocation,
-    updateToiletLocation,
-    deleteToiletLocation,
-    updateToiletLocationChecklist,
-    getToiletLocationById,
-    uploadByFile
+    createUnit,
+    getUnits,
+    updateUnit,
+    deleteUnit,
+    importUnit
   };
 }
 
@@ -1480,22 +1275,9 @@ function useToiletLocationController() {
 var import_node_server_utils9 = require("@iservice365/node-server-utils");
 var import_joi5 = __toESM(require("joi"));
 var import_mongodb5 = require("mongodb");
-var allowedTypes = ["cleaner", "toilet"];
-var allowedStatus = [
-  "To Do",
-  "Pending",
-  "In Progress",
-  "Completed",
-  "Expired"
-];
 var parentChecklistSchema = import_joi5.default.object({
-  date: import_joi5.default.date().required(),
-  status: import_joi5.default.array().items(
-    import_joi5.default.object({
-      type: import_joi5.default.string().required().valid(...allowedTypes),
-      site: import_joi5.default.string().hex().required()
-    })
-  ).optional()
+  createdAt: import_joi5.default.alternatives().try(import_joi5.default.date(), import_joi5.default.string()).optional().allow("", null),
+  site: import_joi5.default.string().hex().required()
 });
 function MParentChecklist(value) {
   const { error } = parentChecklistSchema.validate(value);
@@ -1503,26 +1285,17 @@ function MParentChecklist(value) {
     import_node_server_utils9.logger.info(`Hygiene Parent Checklist Model: ${error.message}`);
     throw new import_node_server_utils9.BadRequestError(error.message);
   }
-  if (value.status && Array.isArray(value.status)) {
-    value.status = value.status.map((item) => {
-      try {
-        return {
-          ...item,
-          site: new import_mongodb5.ObjectId(item.site),
-          status: item.status || "To Do",
-          completedAt: item.completedAt || ""
-        };
-      } catch (error2) {
-        throw new import_node_server_utils9.BadRequestError(
-          `Invalid status site ID format: ${item.site}`
-        );
-      }
-    });
+  if (value.site) {
+    try {
+      value.site = new import_mongodb5.ObjectId(value.site);
+    } catch (error2) {
+      throw new import_node_server_utils9.BadRequestError(`Invalid site ID format: ${value.site}`);
+    }
   }
   return {
-    date: new Date(value.date),
-    status: value.status,
-    createdAt: /* @__PURE__ */ new Date(),
+    site: value.site,
+    status: "ready",
+    createdAt: value.createdAt ?? /* @__PURE__ */ new Date(),
     updatedAt: value.updatedAt ?? ""
   };
 }
@@ -1535,14 +1308,17 @@ function useParentChecklistRepo() {
   if (!db) {
     throw new import_node_server_utils10.InternalServerError("Unable to connect to server.");
   }
-  const namespace_collection = "hygiene-parent-checklist";
+  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_utils10.useCache)(namespace_collection);
   async function createIndex() {
     try {
       await collection.createIndexes([
-        { key: { date: 1 } },
-        { key: { "status.type": 1, "status.site": 1 } }
+        { key: { createdAt: 1 } },
+        { key: { site: 1 } },
+        { key: { status: 1 } }
       ]);
     } catch (error) {
       throw new import_node_server_utils10.InternalServerError(
@@ -1552,13 +1328,13 @@ function useParentChecklistRepo() {
   }
   async function createParentChecklist(value, session) {
     try {
-      const currentDate = value.date ? new Date(value.date) : /* @__PURE__ */ new Date();
+      const currentDate = value.createdAt ? new Date(value.createdAt) : /* @__PURE__ */ new Date();
       const startOfDay = new Date(currentDate);
       startOfDay.setUTCHours(0, 0, 0, 0);
       const endOfDay = new Date(currentDate);
       endOfDay.setUTCHours(23, 59, 59, 999);
       const existingChecklist = await collection.findOne({
-        date: {
+        createdAt: {
           $gte: startOfDay,
           $lte: endOfDay
         }
@@ -1568,8 +1344,25 @@ function useParentChecklistRepo() {
         import_node_server_utils10.logger.info(`Parent checklist already exists for today: ${dateStr2}`);
         return existingChecklist._id;
       }
-      const processedValue = MParentChecklist(value);
-      const result = await collection.insertOne(processedValue, { session });
+      const siteIds = await getHygieneSiteIds();
+      if (!Array.isArray(siteIds)) {
+        import_node_server_utils10.logger.error("getHygieneSiteIds returned non-array value:", siteIds);
+        throw new import_node_server_utils10.InternalServerError("Failed to retrieve site IDs");
+      }
+      if (siteIds.length === 0) {
+        import_node_server_utils10.logger.warn("No sites found for creating parent checklist");
+        throw new import_node_server_utils10.BadRequestError("No sites available for checklist creation");
+      }
+      const checklistDocs = [];
+      for (const site of siteIds) {
+        checklistDocs.push(
+          MParentChecklist({
+            site,
+            createdAt: currentDate
+          })
+        );
+      }
+      const result = await collection.insertMany(checklistDocs, { session });
       delNamespace().then(() => {
         import_node_server_utils10.logger.info(`Cache cleared for namespace: ${namespace_collection}`);
       }).catch((err) => {
@@ -1580,9 +1373,9 @@ function useParentChecklistRepo() {
       });
       const dateStr = currentDate.toISOString().split("T")[0];
       import_node_server_utils10.logger.info(
-        `Created new parent checklist ${result.insertedId} for today: ${dateStr}`
+        `Created ${Object.keys(result.insertedIds).length} parent checklists for today: ${dateStr}`
       );
-      return result.insertedId;
+      return Object.values(result.insertedIds);
     } catch (error) {
       import_node_server_utils10.logger.error("Failed to create daily parent checklist", error);
       throw error;
@@ -1593,7 +1386,6 @@ function useParentChecklistRepo() {
     limit = 10,
     search = "",
     site,
-    type,
     startDate = "",
     endDate = ""
   }) {
@@ -1605,19 +1397,13 @@ function useParentChecklistRepo() {
     };
     try {
       site = new import_mongodb6.ObjectId(site);
+      query.site = site;
       cacheOptions.site = site.toString();
     } catch (error) {
       throw new import_node_server_utils10.BadRequestError("Invalid site ID format.");
     }
-    cacheOptions.type = type;
-    query.status = {
-      $elemMatch: {
-        site: new import_mongodb6.ObjectId(site),
-        type
-      }
-    };
     if (search) {
-      query.$or = [{ name: { $regex: search, $options: "i" } }];
+      query.$text = { $search: search };
       cacheOptions.search = search;
     }
     if (startDate && endDate) {
@@ -1642,35 +1428,24 @@ function useParentChecklistRepo() {
     }
     try {
       const pipeline = [{ $match: query }];
-      const filterConditions = [];
-      filterConditions.push({ $eq: ["$$this.site", new import_mongodb6.ObjectId(site)] });
-      filterConditions.push({ $eq: ["$$this.type", type] });
-      pipeline.push({
-        $addFields: {
-          filteredStatus: {
-            $filter: {
-              input: "$status",
-              cond: { $and: filterConditions }
-            }
-          }
-        }
-      });
-      pipeline.push({
-        $match: {
-          filteredStatus: { $ne: [] }
-        }
-      });
-      pipeline.push({
-        $addFields: {
-          statusObj: { $arrayElemAt: ["$filteredStatus", 0] }
-        }
-      });
       pipeline.push({
         $project: {
           _id: 1,
-          date: 1,
-          status: "$statusObj.status",
-          completedAt: "$statusObj.completedAt",
+          site: 1,
+          status: {
+            $switch: {
+              branches: [
+                { case: { $eq: ["$status", "ready"] }, then: "Ready" },
+                {
+                  case: { $eq: ["$status", "ongoing"] },
+                  then: "Ongoing"
+                },
+                { case: { $eq: ["$status", "completed"] }, then: "Completed" }
+              ],
+              default: "$status"
+            }
+          },
+          completedAt: 1,
           createdAt: 1
         }
       });
@@ -1692,10 +1467,10 @@ function useParentChecklistRepo() {
       throw error;
     }
   }
-  async function updateParentChecklistStatuses(date) {
+  async function updateParentChecklistStatuses(createdAt) {
     try {
       const currentDate = /* @__PURE__ */ new Date();
-      const dateToUpdate = date || new Date(currentDate.getTime() - 24 * 60 * 60 * 1e3);
+      const dateToUpdate = createdAt || new Date(currentDate.getTime() - 24 * 60 * 60 * 1e3);
       const startOfDay = new Date(dateToUpdate);
       startOfDay.setUTCHours(0, 0, 0, 0);
       const endOfDay = new Date(dateToUpdate);
@@ -1714,38 +1489,32 @@ function useParentChecklistRepo() {
         },
         {
           $lookup: {
-            from: "hygiene-checklist.areas",
-            localField: "_id",
-            foreignField: "parentChecklist",
+            from: "site.cleaning.schedule.areas",
+            let: { parentId: "$_id" },
             pipeline: [
+              {
+                $match: {
+                  $expr: { $eq: ["$parentChecklist", "$$parentId"] }
+                }
+              },
               {
                 $group: {
                   _id: {
-                    site: "$site",
-                    type: "$type"
+                    parentChecklist: "$parentChecklist"
                   },
                   completedCount: {
                     $sum: {
-                      $cond: [{ $eq: ["$status", "Completed"] }, 1, 0]
+                      $cond: [{ $eq: ["$status", "completed"] }, 1, 0]
                     }
                   },
-                  inProgressCount: {
+                  ongoingCount: {
                     $sum: {
-                      $cond: [{ $eq: ["$status", "In Progress"] }, 1, 0]
+                      $cond: [{ $eq: ["$status", "ongoing"] }, 1, 0]
                     }
                   },
-                  toDoCount: {
+                  readyCount: {
                     $sum: {
-                      $cond: [
-                        {
-                          $or: [
-                            { $eq: ["$status", "To Do"] },
-                            { $eq: ["$status", "Pending"] }
-                          ]
-                        },
-                        1,
-                        0
-                      ]
+                      $cond: [{ $eq: ["$status", "ready"] }, 1, 0]
                     }
                   },
                   totalCount: { $sum: 1 }
@@ -1758,21 +1527,21 @@ function useParentChecklistRepo() {
                       if: {
                         $and: [
                           { $gt: ["$completedCount", 0] },
-                          { $eq: ["$inProgressCount", 0] },
-                          { $eq: ["$toDoCount", 0] }
+                          { $eq: ["$ongoingCount", 0] },
+                          { $eq: ["$readyCount", 0] }
                         ]
                       },
-                      then: "Completed",
+                      then: "completed",
                       else: {
                         $cond: {
                           if: {
                             $and: [
                               { $eq: ["$completedCount", 0] },
-                              { $eq: ["$inProgressCount", 0] }
+                              { $eq: ["$ongoingCount", 0] }
                             ]
                           },
-                          then: "Expired",
-                          else: "In Progress"
+                          then: "expired",
+                          else: "ongoing"
                         }
                       }
                     }
@@ -1782,8 +1551,8 @@ function useParentChecklistRepo() {
                       if: {
                         $and: [
                           { $gt: ["$completedCount", 0] },
-                          { $eq: ["$inProgressCount", 0] },
-                          { $eq: ["$toDoCount", 0] }
+                          { $eq: ["$ongoingCount", 0] },
+                          { $eq: ["$readyCount", 0] }
                         ]
                       },
                       then: /* @__PURE__ */ new Date(),
@@ -1796,27 +1565,21 @@ function useParentChecklistRepo() {
             as: "areaStats"
           }
         },
+        {
+          $match: {
+            "areaStats.0": { $exists: true }
+          }
+        },
         {
           $addFields: {
-            newStatus: {
-              $map: {
-                input: "$areaStats",
-                as: "stat",
-                in: {
-                  site: "$$stat._id.site",
-                  type: "$$stat._id.type",
-                  status: "$$stat.finalStatus",
-                  completedAt: "$$stat.completedAt"
-                }
-              }
-            }
+            areaData: { $arrayElemAt: ["$areaStats", 0] }
           }
         },
-        { $match: { newStatus: { $ne: [] } } },
         {
           $project: {
             _id: 1,
-            newStatus: 1
+            newStatus: "$areaData.finalStatus",
+            completedAt: "$areaData.completedAt"
           }
         }
       ]).toArray();
@@ -1830,9 +1593,8 @@ function useParentChecklistRepo() {
         return null;
       }
       const bulkOps = statusUpdates.map((update) => {
-        const statusTypes = update.newStatus.map((s) => `${s.type}(${s.status})`).join(", ");
         import_node_server_utils10.logger.info(
-          `Updating parent checklist ${update._id} with ${update.newStatus.length} status entries: [${statusTypes}]`
+          `Updating parent checklist ${update._id} with status: ${update.newStatus}`
         );
         return {
           updateOne: {
@@ -1840,6 +1602,7 @@ function useParentChecklistRepo() {
             update: {
               $set: {
                 status: update.newStatus,
+                completedAt: update.completedAt,
                 updatedAt: /* @__PURE__ */ new Date()
               }
             }
@@ -1865,6 +1628,36 @@ function useParentChecklistRepo() {
       throw error;
     }
   }
+  async function getHygieneSiteIds() {
+    const query = {
+      status: { $ne: "deleted" }
+    };
+    const cacheKey = (0, import_node_server_utils10.makeCacheKey)(site_collection, { tag: "site-ids" });
+    const cachedData = await getCache(cacheKey);
+    if (cachedData && Array.isArray(cachedData)) {
+      import_node_server_utils10.logger.info(`Cache hit for key: ${cacheKey}`);
+      return cachedData;
+    }
+    try {
+      const items = await siteCollection.aggregate([
+        { $match: query },
+        { $project: { _id: 1 } },
+        { $sort: { _id: -1 } }
+      ]).toArray();
+      const siteIds = items.map((item) => item._id.toString());
+      if (siteIds.length > 0) {
+        setCache(cacheKey, siteIds, 15 * 60).then(() => {
+          import_node_server_utils10.logger.info(`Cache set for key: ${cacheKey}`);
+        }).catch((err) => {
+          import_node_server_utils10.logger.error(`Failed to set cache for key: ${cacheKey}`, err);
+        });
+      }
+      return siteIds;
+    } catch (error) {
+      import_node_server_utils10.logger.error("Failed to get hygiene site IDs", error);
+      throw error;
+    }
+  }
   return {
     createIndex,
     createParentChecklist,
@@ -1906,7 +1699,6 @@ function useParentChecklistController() {
       limit: import_joi6.default.number().min(1).optional().allow("", null),
       search: import_joi6.default.string().optional().allow("", null),
       site: import_joi6.default.string().hex().required(),
-      type: import_joi6.default.string().required().valid(...allowedTypes),
       startDate: import_joi6.default.alternatives().try(import_joi6.default.date(), import_joi6.default.string()).optional().allow("", null),
       endDate: import_joi6.default.alternatives().try(import_joi6.default.date(), import_joi6.default.string()).optional().allow("", null)
     });
@@ -1916,1299 +1708,119 @@ function useParentChecklistController() {
       next(new import_node_server_utils11.BadRequestError(error.message));
       return;
     }
-    const page = parseInt(req.query.page) ?? 1;
-    const limit = parseInt(req.query.limit) ?? 20;
-    const search = req.query.search ?? "";
-    const site = req.params.site ?? "";
-    const type = req.params.type ?? "";
-    const startDate = req.query.startDate ?? "";
-    const endDate = req.query.endDate ?? "";
-    try {
-      const data = await _getAllParentChecklist({
-        page,
-        limit,
-        search,
-        site,
-        type,
-        startDate,
-        endDate
-      });
-      res.json(data);
-      return;
-    } catch (error2) {
-      import_node_server_utils11.logger.log({ level: "error", message: error2.message });
-      next(error2);
-      return;
-    }
-  }
-  return {
-    createParentChecklist,
-    getAllParentChecklist
-  };
-}
-
-// src/models/hygiene-unit.model.ts
-var import_node_server_utils12 = require("@iservice365/node-server-utils");
-var import_joi7 = __toESM(require("joi"));
-var import_mongodb7 = require("mongodb");
-var unitSchema = import_joi7.default.object({
-  name: import_joi7.default.string().required(),
-  site: import_joi7.default.string().hex().required(),
-  createdBy: import_joi7.default.string().hex().required()
-});
-function MUnit(value) {
-  const { error } = unitSchema.validate(value);
-  if (error) {
-    import_node_server_utils12.logger.info(`Hygiene Unit Model: ${error.message}`);
-    throw new import_node_server_utils12.BadRequestError(error.message);
-  }
-  if (value.site) {
-    try {
-      value.site = new import_mongodb7.ObjectId(value.site);
-    } catch (error2) {
-      throw new import_node_server_utils12.BadRequestError("Invalid site ID format.");
-    }
-  }
-  if (value.createdBy) {
-    try {
-      value.createdBy = new import_mongodb7.ObjectId(value.createdBy);
-    } catch (error2) {
-      throw new import_node_server_utils12.BadRequestError("Invalid createdBy ID format.");
-    }
-  }
-  return {
-    name: value.name,
-    createdBy: value.createdBy,
-    site: value.site,
-    status: "active",
-    createdAt: /* @__PURE__ */ new Date(),
-    updatedAt: value.updatedAt ?? "",
-    deletedAt: value.deletedAt ?? ""
-  };
-}
-
-// src/services/hygiene-unit.service.ts
-var import_node_server_utils14 = require("@iservice365/node-server-utils");
-
-// src/repositories/hygiene-unit.repository.ts
-var import_mongodb8 = require("mongodb");
-var import_node_server_utils13 = require("@iservice365/node-server-utils");
-function useUnitRepository() {
-  const db = import_node_server_utils13.useAtlas.getDb();
-  if (!db) {
-    throw new import_node_server_utils13.InternalServerError("Unable to connect to server.");
-  }
-  const namespace_collection = "hygiene-units";
-  const collection = db.collection(namespace_collection);
-  const { delNamespace, setCache, getCache } = (0, import_node_server_utils13.useCache)(namespace_collection);
-  async function createIndex() {
-    try {
-      await collection.createIndexes([
-        { key: { site: 1 } },
-        { key: { createdBy: 1 } },
-        { key: { status: 1 } }
-      ]);
-    } catch (error) {
-      throw new import_node_server_utils13.InternalServerError("Failed to create index on hygiene unit.");
-    }
-  }
-  async function createTextIndex() {
-    try {
-      await collection.createIndex({ name: "text" });
-    } catch (error) {
-      throw new import_node_server_utils13.InternalServerError(
-        "Failed to create text index on hygiene unit."
-      );
-    }
-  }
-  async function createUniqueIndex() {
-    try {
-      await collection.createIndex(
-        { name: 1, site: 1, deletedAt: 1 },
-        { unique: true }
-      );
-    } catch (error) {
-      throw new import_node_server_utils13.InternalServerError(
-        "Failed to create unique index on hygiene unit."
-      );
-    }
-  }
-  async function createUnit(value, session) {
-    try {
-      value = MUnit(value);
-      const res = await collection.insertOne(value, { session });
-      delNamespace().then(() => {
-        import_node_server_utils13.logger.info(`Cache cleared for namespace: ${namespace_collection}`);
-      }).catch((err) => {
-        import_node_server_utils13.logger.error(
-          `Failed to clear cache for namespace: ${namespace_collection}`,
-          err
-        );
-      });
-      return res.insertedId;
-    } catch (error) {
-      const isDuplicated = error.message.includes("duplicate");
-      if (isDuplicated) {
-        throw new import_node_server_utils13.BadRequestError("Unit already exists.");
-      }
-      throw error;
-    }
-  }
-  async function getUnits({
-    page = 1,
-    limit = 10,
-    search = "",
-    startDate = "",
-    endDate = "",
-    site = ""
-  }) {
-    page = page > 0 ? page - 1 : 0;
-    try {
-      site = new import_mongodb8.ObjectId(site);
-    } catch (error) {
-      throw new import_node_server_utils13.BadRequestError("Invalid site ID format.");
-    }
-    const query = {
-      status: { $ne: "deleted" },
-      site
-    };
-    const cacheOptions = {
-      page,
-      limit,
-      site: site.toString()
-    };
-    if (search) {
-      query.$or = [{ name: { $regex: search, $options: "i" } }];
-      cacheOptions.search = search;
-    }
-    if (startDate && endDate) {
-      query.createdAt = {
-        $gte: new Date(startDate),
-        $lte: new Date(endDate)
-      };
-      cacheOptions.startDate = new Date(startDate).toISOString().split("T")[0];
-      cacheOptions.endDate = new Date(endDate).toISOString().split("T")[0];
-    } else if (startDate) {
-      query.createdAt = { $gte: new Date(startDate) };
-      cacheOptions.startDate = new Date(startDate).toISOString().split("T")[0];
-    } else if (endDate) {
-      query.createdAt = { $lte: new Date(endDate) };
-      cacheOptions.endDate = new Date(endDate).toISOString().split("T")[0];
-    }
-    const cacheKey = (0, import_node_server_utils13.makeCacheKey)(namespace_collection, cacheOptions);
-    const cachedData = await getCache(cacheKey);
-    if (cachedData) {
-      import_node_server_utils13.logger.info(`Cache hit for key: ${cacheKey}`);
-      return cachedData;
-    }
-    try {
-      const items = await collection.aggregate([
-        { $match: query },
-        {
-          $lookup: {
-            from: "sites",
-            localField: "site",
-            foreignField: "_id",
-            pipeline: [{ $project: { name: 1 } }],
-            as: "site"
-          }
-        },
-        {
-          $unwind: {
-            path: "$site",
-            preserveNullAndEmptyArrays: true
-          }
-        },
-        {
-          $lookup: {
-            from: "users",
-            localField: "createdBy",
-            foreignField: "_id",
-            pipeline: [{ $project: { name: 1 } }],
-            as: "createdBy"
-          }
-        },
-        {
-          $unwind: {
-            path: "$createdBy",
-            preserveNullAndEmptyArrays: true
-          }
-        },
-        {
-          $project: {
-            name: 1,
-            site: "$site._id",
-            siteName: "$site.name",
-            createdByName: "$createdBy.name",
-            checklist: 1,
-            status: 1,
-            createdAt: 1
-          }
-        },
-        { $sort: { _id: -1 } },
-        { $skip: page * limit },
-        { $limit: limit }
-      ]).toArray();
-      const length = await collection.countDocuments(query);
-      const data = (0, import_node_server_utils13.paginate)(items, page, limit, length);
-      setCache(cacheKey, data, 15 * 60).then(() => {
-        import_node_server_utils13.logger.info(`Cache set for key: ${cacheKey}`);
-      }).catch((err) => {
-        import_node_server_utils13.logger.error(`Failed to set cache for key: ${cacheKey}`, err);
-      });
-      return data;
-    } catch (error) {
-      throw error;
-    }
-  }
-  async function getUnitByName(name, site) {
-    try {
-      if (site)
-        site = new import_mongodb8.ObjectId(site);
-    } catch (error) {
-      throw new import_node_server_utils13.BadRequestError("Invalid site ID format.");
-    }
-    try {
-      return await collection.findOne({
-        name: { $regex: new RegExp(`^${name}$`, "i") },
-        ...site && { site }
-      });
-    } catch (error) {
-      throw new import_node_server_utils13.BadRequestError("Unable to fetch unit by name.");
-    }
-  }
-  async function getUnitById(id, site) {
-    try {
-      id = typeof id === "string" ? new import_mongodb8.ObjectId(id) : id;
-    } catch (error) {
-      throw new import_node_server_utils13.BadRequestError("Invalid unit ID format.");
-    }
-    try {
-      if (site)
-        site = new import_mongodb8.ObjectId(site);
-    } catch (error) {
-      throw new import_node_server_utils13.BadRequestError(
-        "Unable to fetch unit by ID, Invalid site ID format."
-      );
-    }
-    try {
-      return await collection.findOne({ _id: id, ...site && { site } });
-    } catch (error) {
-      throw new import_node_server_utils13.BadRequestError("Unable to fetch unit by id.");
-    }
-  }
-  async function updateUnit(_id, value) {
-    try {
-      _id = new import_mongodb8.ObjectId(_id);
-    } catch (error) {
-      throw new import_node_server_utils13.BadRequestError("Invalid unit ID format.");
-    }
-    try {
-      const updateValue = { ...value, updatedAt: /* @__PURE__ */ new Date() };
-      const res = await collection.updateOne({ _id }, { $set: updateValue });
-      if (res.modifiedCount === 0) {
-        throw new import_node_server_utils13.InternalServerError("Unable to update cleaning unit.");
-      }
-      delNamespace().then(() => {
-        import_node_server_utils13.logger.info(`Cache cleared for namespace: ${namespace_collection}`);
-      }).catch((err) => {
-        import_node_server_utils13.logger.error(
-          `Failed to clear cache for namespace: ${namespace_collection}`,
-          err
-        );
-      });
-      return res.modifiedCount;
-    } catch (error) {
-      const isDuplicated = error.message.includes("duplicate");
-      if (isDuplicated) {
-        throw new import_node_server_utils13.BadRequestError("Area already exists.");
-      }
-      throw error;
-    }
-  }
-  async function deleteUnit(_id, session) {
-    try {
-      _id = new import_mongodb8.ObjectId(_id);
-    } catch (error) {
-      throw new import_node_server_utils13.BadRequestError("Invalid unit ID format.");
-    }
-    try {
-      const updateValue = {
-        status: "deleted",
-        updatedAt: /* @__PURE__ */ new Date(),
-        deletedAt: /* @__PURE__ */ new Date()
-      };
-      const res = await collection.updateOne(
-        { _id },
-        { $set: updateValue },
-        { session }
-      );
-      if (res.modifiedCount === 0) {
-        throw new import_node_server_utils13.InternalServerError("Unable to delete unit.");
-      }
-      delNamespace().then(() => {
-        import_node_server_utils13.logger.info(`Cache cleared for namespace: ${namespace_collection}`);
-      }).catch((err) => {
-        import_node_server_utils13.logger.error(
-          `Failed to clear cache for namespace: ${namespace_collection}`,
-          err
-        );
-      });
-      return res.modifiedCount;
-    } catch (error) {
-      throw error;
-    }
-  }
-  return {
-    createIndex,
-    createTextIndex,
-    createUniqueIndex,
-    createUnit,
-    getUnits,
-    getUnitByName,
-    getUnitById,
-    updateUnit,
-    deleteUnit
-  };
-}
-
-// src/services/hygiene-unit.service.ts
-function useUnitService() {
-  const { createUnit: _createUnit } = useUnitRepository();
-  async function uploadByFile({
-    dataJson,
-    createdBy,
-    site
-  }) {
-    let dataArray;
-    try {
-      dataArray = JSON.parse(dataJson);
-    } catch (error) {
-      throw new import_node_server_utils14.BadRequestError("Invalid JSON format for data in excel");
-    }
-    if (!dataArray || dataArray.length === 0) {
-      throw new import_node_server_utils14.NotFoundError("No data found in the uploaded file");
-    }
-    const session = import_node_server_utils14.useAtlas.getClient()?.startSession();
-    const insertedUnitIds = [];
-    try {
-      session?.startTransaction();
-      for (const row of dataArray) {
-        if (!row?.UNIT_NAME) {
-          import_node_server_utils14.logger.warn("Skipping row with missing UNIT_NAME:", row);
-          continue;
-        }
-        try {
-          const insertedId = await _createUnit(
-            {
-              name: String(row.UNIT_NAME).trim(),
-              site,
-              createdBy
-            },
-            session
-          );
-          insertedUnitIds.push(insertedId);
-        } catch (error) {
-          import_node_server_utils14.logger.error(
-            `Error creating unit "${row.UNIT_NAME}":`,
-            error.message
-          );
-          continue;
-        }
-      }
-      await session?.commitTransaction();
-      import_node_server_utils14.logger.info(`Successfully uploaded ${insertedUnitIds.length} units`);
-      return {
-        message: `Successfully uploaded ${insertedUnitIds.length} units`
-      };
-    } catch (error) {
-      await session?.abortTransaction();
-      import_node_server_utils14.logger.error("Error while uploading unit information", error);
-      throw error;
-    } finally {
-      session?.endSession();
-    }
-  }
-  return {
-    uploadByFile
-  };
-}
-
-// src/controllers/hygiene-unit.controller.ts
-var import_node_server_utils15 = require("@iservice365/node-server-utils");
-var import_joi8 = __toESM(require("joi"));
-function useUnitController() {
-  const {
-    createUnit: _createUnit,
-    getUnits: _getUnits,
-    updateUnit: _updateUnit,
-    deleteUnit: _deleteUnit
-  } = useUnitRepository();
-  const { uploadByFile: _uploadByFile } = useUnitService();
-  async function createUnit(req, res, next) {
-    const cookies = req.headers.cookie ? req.headers.cookie.split(";").map((cookie) => cookie.trim().split("=")).reduce(
-      (acc, [key, value]) => ({ ...acc, [key]: value }),
-      {}
-    ) : {};
-    const createdBy = cookies["user"] || "";
-    const payload = { ...req.body, createdBy };
-    const { error } = unitSchema.validate(payload);
-    if (error) {
-      import_node_server_utils15.logger.log({ level: "error", message: error.message });
-      next(new import_node_server_utils15.BadRequestError(error.message));
-      return;
-    }
-    try {
-      const id = await _createUnit(payload);
-      res.status(201).json({ message: "Unit created successfully.", id });
-      return;
-    } catch (error2) {
-      import_node_server_utils15.logger.log({ level: "error", message: error2.message });
-      next(error2);
-      return;
-    }
-  }
-  async function getAll(req, res, next) {
-    const query = req.query;
-    const validation = import_joi8.default.object({
-      page: import_joi8.default.number().min(1).optional().allow("", null),
-      limit: import_joi8.default.number().min(1).optional().allow("", null),
-      search: import_joi8.default.string().optional().allow("", null),
-      startDate: import_joi8.default.alternatives().try(import_joi8.default.date(), import_joi8.default.string()).optional().allow("", null),
-      endDate: import_joi8.default.alternatives().try(import_joi8.default.date(), import_joi8.default.string()).optional().allow("", null),
-      site: import_joi8.default.string().hex().optional().allow("", null)
-    });
-    const { error } = validation.validate(query);
-    if (error) {
-      import_node_server_utils15.logger.log({ level: "error", message: error.message });
-      next(new import_node_server_utils15.BadRequestError(error.message));
-      return;
-    }
-    const page = parseInt(req.query.page) ?? 1;
-    const limit = parseInt(req.query.limit) ?? 20;
-    const search = req.query.search ?? "";
-    const site = req.query.site ?? "";
-    const startDate = req.query.startDate ?? "";
-    const endDate = req.query.endDate ?? "";
-    try {
-      const data = await _getUnits({
-        page,
-        limit,
-        search,
-        site,
-        startDate,
-        endDate
-      });
-      res.json(data);
-      return;
-    } catch (error2) {
-      import_node_server_utils15.logger.log({ level: "error", message: error2.message });
-      next(error2);
-      return;
-    }
-  }
-  async function updateUnit(req, res, next) {
-    const payload = { id: req.params.id, ...req.body };
-    const schema = import_joi8.default.object({
-      id: import_joi8.default.string().hex().required(),
-      name: import_joi8.default.string().required()
-    });
-    const { error } = schema.validate(payload);
-    if (error) {
-      import_node_server_utils15.logger.log({ level: "error", message: error.message });
-      next(new import_node_server_utils15.BadRequestError(error.message));
-      return;
-    }
-    try {
-      const { id, ...value } = payload;
-      await _updateUnit(id, value);
-      res.json({ message: "Unit updated successfully." });
-      return;
-    } catch (error2) {
-      import_node_server_utils15.logger.log({ level: "error", message: error2.message });
-      next(error2);
-      return;
-    }
-  }
-  async function deleteUnit(req, res, next) {
-    const id = req.params.id;
-    const validation = import_joi8.default.object({
-      id: import_joi8.default.string().hex().required()
-    });
-    const { error } = validation.validate({ id });
-    if (error) {
-      import_node_server_utils15.logger.log({ level: "error", message: error.message });
-      next(new import_node_server_utils15.BadRequestError(error.message));
-      return;
-    }
-    try {
-      await _deleteUnit(id);
-      res.json({ message: "Unit deleted successfully." });
-      return;
-    } catch (error2) {
-      import_node_server_utils15.logger.log({ level: "error", message: error2.message });
-      next(error2);
-      return;
-    }
-  }
-  async function uploadByFile(req, res, next) {
-    if (!req.file) {
-      next(new import_node_server_utils15.BadRequestError("File is required!"));
-      return;
-    }
-    const cookies = req.headers.cookie ? req.headers.cookie.split(";").map((cookie) => cookie.trim().split("=")).reduce(
-      (acc, [key, value]) => ({ ...acc, [key]: value }),
-      {}
-    ) : {};
-    const createdBy = cookies["user"] || "";
-    const { site } = req.body;
-    const schema = import_joi8.default.object({
-      site: import_joi8.default.string().hex().optional().allow("", null),
-      createdBy: import_joi8.default.string().hex().required()
-    });
-    const { error } = schema.validate({ site, createdBy });
-    if (error) {
-      import_node_server_utils15.logger.log({ level: "error", message: error.message });
-      next(new import_node_server_utils15.BadRequestError(error.message));
-      return;
-    }
-    try {
-      const xlsData = await convertBufferFile(req.file.buffer);
-      const dataJson = JSON.stringify(xlsData);
-      const result = await _uploadByFile({ dataJson, createdBy, site });
-      return res.status(201).json(result);
-    } catch (error2) {
-      import_node_server_utils15.logger.log({ level: "error", message: error2.message });
-      next(error2);
-      return;
-    }
-  }
-  return {
-    createUnit,
-    getAll,
-    updateUnit,
-    deleteUnit,
-    uploadByFile
-  };
-}
-
-// src/models/hygiene-schedule-task-area.model.ts
-var import_node_server_utils16 = require("@iservice365/node-server-utils");
-var import_joi9 = __toESM(require("joi"));
-var import_mongodb9 = require("mongodb");
-var scheduleTaskAreaSchema = import_joi9.default.object({
-  name: import_joi9.default.string().required(),
-  site: import_joi9.default.string().hex().required(),
-  createdBy: import_joi9.default.string().hex().required(),
-  checklist: import_joi9.default.array().items(
-    import_joi9.default.object({
-      _id: import_joi9.default.string().hex().required(),
-      name: import_joi9.default.string().required()
-    })
-  ).optional(),
-  updatedAt: import_joi9.default.date().optional().allow("", null),
-  status: import_joi9.default.string().allow("", null).optional()
-});
-function MScheduleTaskArea(value) {
-  const { error } = scheduleTaskAreaSchema.validate(value);
-  if (error) {
-    throw new import_node_server_utils16.BadRequestError(error.message);
-  }
-  if (value.site) {
-    try {
-      value.site = new import_mongodb9.ObjectId(value.site);
-    } catch (error2) {
-      throw new import_node_server_utils16.BadRequestError("Invalid site ID format.");
-    }
-  }
-  if (value.createdBy) {
-    try {
-      value.createdBy = new import_mongodb9.ObjectId(value.createdBy);
-    } catch (error2) {
-      throw new import_node_server_utils16.BadRequestError("Invalid createdBy ID format.");
-    }
-  }
-  if (value.checklist && Array.isArray(value.checklist)) {
-    value.checklist = value.checklist.map((item) => {
-      try {
-        return {
-          ...item,
-          _id: new import_mongodb9.ObjectId(item._id)
-        };
-      } catch (error2) {
-        throw new import_node_server_utils16.BadRequestError(
-          `Invalid checklist item ID format: ${item._id}`
-        );
-      }
-    });
-  }
-  return {
-    name: value.name,
-    site: value.site,
-    createdBy: value.createdBy,
-    checklist: value.checklist,
-    status: value.status ?? "",
-    createdAt: /* @__PURE__ */ new Date(),
-    updatedAt: value.updatedAt ?? "",
-    deletedAt: value.deletedAt ?? ""
-  };
-}
-
-// src/repositories/hygiene-schedule-task-area.repository.ts
-var import_mongodb10 = require("mongodb");
-var import_node_server_utils17 = require("@iservice365/node-server-utils");
-function useScheduleTaskAreaRepository() {
-  const db = import_node_server_utils17.useAtlas.getDb();
-  if (!db) {
-    throw new import_node_server_utils17.InternalServerError("Unable to connect to server.");
-  }
-  const namespace_collection = "hygiene-schedule-task-areas";
-  const collection = db.collection(namespace_collection);
-  const { delNamespace, setCache, getCache, delCache } = (0, import_node_server_utils17.useCache)(namespace_collection);
-  async function createIndexes() {
-    try {
-      await collection.createIndexes([
-        { key: { site: 1 } },
-        { key: { name: "text" } }
-      ]);
-    } catch (error) {
-      throw new import_node_server_utils17.InternalServerError("Failed to create index on site.");
-    }
-  }
-  async function createUniqueIndex() {
-    try {
-      await collection.createIndex(
-        { name: 1, site: 1, deletedAt: 1 },
-        { unique: true }
-      );
-    } catch (error) {
-      throw new import_node_server_utils17.InternalServerError(
-        "Failed to create unique index on hygiene area."
-      );
-    }
-  }
-  async function createScheduleTaskArea(value, session) {
-    try {
-      value = MScheduleTaskArea(value);
-      const res = await collection.insertOne(value, { session });
-      delNamespace().then(() => {
-        import_node_server_utils17.logger.info(`Cache cleared for namespace: ${namespace_collection}`);
-      }).catch((err) => {
-        import_node_server_utils17.logger.error(
-          `Failed to clear cache for namespace: ${namespace_collection}`,
-          err
-        );
-      });
-      return res.insertedId;
-    } catch (error) {
-      const isDuplicated = error.message.includes("duplicate");
-      if (isDuplicated) {
-        throw new import_node_server_utils17.BadRequestError("Area already exists.");
-      }
-      throw error;
-    }
-  }
-  async function updateScheduleTaskArea(_id, params) {
-    try {
-      _id = new import_mongodb10.ObjectId(_id);
-    } catch (error) {
-      throw new import_node_server_utils17.BadRequestError("Invalid area ID format.");
-    }
-    try {
-      const updateValue = { ...params, updatedAt: /* @__PURE__ */ new Date() };
-      const res = await collection.updateOne({ _id }, { $set: updateValue });
-      if (res.modifiedCount === 0) {
-        throw new import_node_server_utils17.InternalServerError("Unable to update cleaning area.");
-      }
-      delNamespace().then(() => {
-        import_node_server_utils17.logger.info(`Cache cleared for namespace: ${namespace_collection}`);
-      }).catch((err) => {
-        import_node_server_utils17.logger.error(
-          `Failed to clear cache for namespace: ${namespace_collection}`,
-          err
-        );
-      });
-      return res.modifiedCount;
-    } catch (error) {
-      const isDuplicated = error.message.includes("duplicate");
-      if (isDuplicated) {
-        throw new import_node_server_utils17.BadRequestError("Area already exists.");
-      }
-      throw error;
-    }
-  }
-  async function deleteScheduleTaskArea(_id, session) {
-    try {
-      _id = new import_mongodb10.ObjectId(_id);
-    } catch (error) {
-      throw new import_node_server_utils17.BadRequestError("Invalid area ID format.");
-    }
-    try {
-      const updateValue = {
-        status: "deleted",
-        updatedAt: /* @__PURE__ */ new Date(),
-        deletedAt: /* @__PURE__ */ new Date()
-      };
-      const res = await collection.updateOne(
-        { _id },
-        { $set: updateValue },
-        { session }
-      );
-      if (res.modifiedCount === 0) {
-        throw new import_node_server_utils17.InternalServerError("Unable to delete area.");
-      }
-      delNamespace().then(() => {
-        import_node_server_utils17.logger.info(`Cache cleared for namespace: ${namespace_collection}`);
-      }).catch((err) => {
-        import_node_server_utils17.logger.error(
-          `Failed to clear cache for namespace: ${namespace_collection}`,
-          err
-        );
-      });
-      return res.modifiedCount;
-    } catch (error) {
-      throw error;
-    }
-  }
-  async function getScheduleTaskAreas({
-    page = 1,
-    limit = 10,
-    search = "",
-    startDate = "",
-    endDate = "",
-    site = ""
-  }) {
-    page = page > 0 ? page - 1 : 0;
-    const query = {
-      status: { $ne: "deleted" }
-    };
-    const cacheOptions = {
-      page,
-      limit
-    };
-    if (site) {
-      try {
-        site = new import_mongodb10.ObjectId(site);
-        cacheOptions.site = site.toString();
-      } catch (error) {
-        throw new import_node_server_utils17.BadRequestError("Invalid site ID format.");
-      }
-    }
-    if (search) {
-      query.$or = [{ name: { $regex: search, $options: "i" } }];
-      cacheOptions.search = search;
-    }
-    if (startDate && endDate) {
-      query.createdAt = {
-        $gte: new Date(startDate),
-        $lte: new Date(endDate)
-      };
-      cacheOptions.startDate = new Date(startDate).toISOString().split("T")[0];
-      cacheOptions.endDate = new Date(endDate).toISOString().split("T")[0];
-    } else if (startDate) {
-      query.createdAt = { $gte: new Date(startDate) };
-      cacheOptions.startDate = new Date(startDate).toISOString().split("T")[0];
-    } else if (endDate) {
-      query.createdAt = { $lte: new Date(endDate) };
-      cacheOptions.endDate = new Date(endDate).toISOString().split("T")[0];
-    }
-    const cacheKey = (0, import_node_server_utils17.makeCacheKey)(namespace_collection, cacheOptions);
-    const cachedData = await getCache(cacheKey);
-    if (cachedData) {
-      import_node_server_utils17.logger.info(`Cache hit for key: ${cacheKey}`);
-      return cachedData;
-    }
-    try {
-      const items = await collection.aggregate([
-        {
-          $match: query
-        },
-        {
-          $lookup: {
-            from: "sites",
-            localField: "site",
-            foreignField: "_id",
-            pipeline: [{ $project: { name: 1 } }],
-            as: "site"
-          }
-        },
-        {
-          $unwind: {
-            path: "$site",
-            preserveNullAndEmptyArrays: true
-          }
-        },
-        {
-          $lookup: {
-            from: "users",
-            localField: "createdBy",
-            foreignField: "_id",
-            pipeline: [{ $project: { name: 1 } }],
-            as: "createdBy"
-          }
-        },
-        {
-          $unwind: {
-            path: "$createdBy",
-            preserveNullAndEmptyArrays: true
-          }
-        },
-        {
-          $project: {
-            name: 1,
-            site: "$site._id",
-            siteName: "$site.name",
-            createdByName: "$createdBy.name",
-            checklist: 1,
-            status: 1,
-            createdAt: 1
-          }
-        },
-        { $sort: { _id: -1 } },
-        { $skip: page * limit },
-        { $limit: limit }
-      ]).toArray();
-      const length = await collection.countDocuments(query);
-      const data = (0, import_node_server_utils17.paginate)(items, page, limit, length);
-      setCache(cacheKey, data, 15 * 60).then(() => {
-        import_node_server_utils17.logger.info(`Cache set for key: ${cacheKey}`);
-      }).catch((err) => {
-        import_node_server_utils17.logger.error(`Failed to set cache for key: ${cacheKey}`, err);
-      });
-      return data;
-    } catch (error) {
-      throw error;
-    }
-  }
-  async function getScheduleTaskAreaByName(name, site) {
-    try {
-      if (site)
-        site = new import_mongodb10.ObjectId(site);
-    } catch (error) {
-      throw new import_node_server_utils17.BadRequestError("Invalid site ID format.");
-    }
-    try {
-      return await collection.findOne({
-        name: { $regex: new RegExp(`^${name}$`, "i") },
-        ...site && { site }
-      });
-    } catch (error) {
-      throw new import_node_server_utils17.BadRequestError("Unable to fetch schedule task area by name.");
-    }
-  }
-  async function getScheduleTaskAreaById(id, site) {
-    try {
-      id = typeof id === "string" ? new import_mongodb10.ObjectId(id) : id;
-    } catch (error) {
-      throw new import_node_server_utils17.BadRequestError("Invalid unit ID format.");
-    }
-    try {
-      if (site)
-        site = new import_mongodb10.ObjectId(site);
-    } catch (error) {
-      throw new import_node_server_utils17.BadRequestError(
-        "Unable to fetch schedule task area by ID, Invalid site ID format."
-      );
-    }
-    try {
-      return await collection.findOne({ _id: id, ...site && { site } });
-    } catch (error) {
-      throw new import_node_server_utils17.BadRequestError("Unable to fetch schedule task area by id.");
-    }
-  }
-  async function getAreaById(_id) {
-    try {
-      _id = new import_mongodb10.ObjectId(_id);
-    } catch (error) {
-      throw new import_node_server_utils17.BadRequestError("Invalid area ID format.");
-    }
-    const query = {
-      _id,
-      status: { $ne: "deleted" }
-    };
-    const cacheKey = (0, import_node_server_utils17.makeCacheKey)(namespace_collection, {
-      _id: _id.toString()
-    });
-    const cachedData = await getCache(cacheKey);
-    if (cachedData) {
-      import_node_server_utils17.logger.info(`Cache hit for key: ${cacheKey}`);
-      return cachedData;
-    }
-    try {
-      const data = await collection.aggregate([
-        { $match: query },
-        {
-          $project: {
-            name: 1,
-            checklist: 1
-          }
-        }
-      ]).toArray();
-      if (!data || !data.length) {
-        throw new import_node_server_utils17.NotFoundError("Area not found.");
-      }
-      setCache(cacheKey, data[0], 15 * 60).then(() => {
-        import_node_server_utils17.logger.info(`Cache set for key: ${cacheKey}`);
-      }).catch((err) => {
-        import_node_server_utils17.logger.error(`Failed to set cache for key: ${cacheKey}`, err);
-      });
-      return data[0];
-    } catch (error) {
-      throw error;
-    }
-  }
-  return {
-    createUniqueIndex,
-    createScheduleTaskArea,
-    updateScheduleTaskArea,
-    deleteScheduleTaskArea,
-    getScheduleTaskAreas,
-    createIndexes,
-    getScheduleTaskAreaByName,
-    getScheduleTaskAreaById,
-    getAreaById
-  };
-}
-
-// src/services/hygiene-schedule-task-area.service.ts
-var import_node_server_utils18 = require("@iservice365/node-server-utils");
-function useScheduleTaskAreaService() {
-  const { createScheduleTaskArea: _create } = useScheduleTaskAreaRepository();
-  async function uploadByFile({
-    dataJson,
-    createdBy,
-    site
-  }) {
-    let dataArray;
-    try {
-      dataArray = JSON.parse(dataJson);
-    } catch (error) {
-      throw new import_node_server_utils18.BadRequestError("Invalid JSON format for data in excel");
-    }
-    if (!dataArray || dataArray.length === 0) {
-      throw new import_node_server_utils18.NotFoundError("No data found in the uploaded file");
-    }
-    const session = import_node_server_utils18.useAtlas.getClient()?.startSession();
-    const insertedAreaIds = [];
-    try {
-      session?.startTransaction();
-      for (const row of dataArray) {
-        if (!row?.AREA_NAME) {
-          import_node_server_utils18.logger.warn("Skipping row with missing AREA_NAME:", row);
-          continue;
-        }
-        try {
-          const insertedId = await _create(
-            {
-              name: String(row.AREA_NAME).trim(),
-              site,
-              createdBy
-            },
-            session
-          );
-          insertedAreaIds.push(insertedId);
-        } catch (error) {
-          import_node_server_utils18.logger.error(
-            `Error creating area "${row.AREA_NAME}":`,
-            error.message
-          );
-          continue;
-        }
-      }
-      await session?.commitTransaction();
-      import_node_server_utils18.logger.info(`Successfully uploaded ${insertedAreaIds.length} areas`);
-      return {
-        message: `Successfully uploaded ${insertedAreaIds.length} areas`
-      };
-    } catch (error) {
-      await session?.abortTransaction();
-      import_node_server_utils18.logger.error("Error while uploading area information", error);
-      throw error;
-    } finally {
-      session?.endSession();
-    }
-  }
-  return {
-    uploadByFile
-  };
-}
-
-// src/controllers/hygiene-schedule-task-area.controller.ts
-var import_node_server_utils19 = require("@iservice365/node-server-utils");
-var import_joi10 = __toESM(require("joi"));
-function useScheduleTaskAreaController() {
-  const { uploadByFile: _uploadByFile } = useScheduleTaskAreaService();
-  const {
-    getScheduleTaskAreas: _getAll,
-    createScheduleTaskArea: _createScheduleTaskArea,
-    updateScheduleTaskArea: _updateScheduleTaskArea,
-    deleteScheduleTaskArea: _deleteById,
-    getAreaById: _getAreaById
-  } = useScheduleTaskAreaRepository();
-  async function getAll(req, res, next) {
-    const query = req.query;
-    const validation = import_joi10.default.object({
-      page: import_joi10.default.number().min(1).optional().allow("", null),
-      limit: import_joi10.default.number().min(1).optional().allow("", null),
-      search: import_joi10.default.string().optional().allow("", null),
-      startDate: import_joi10.default.alternatives().try(import_joi10.default.date(), import_joi10.default.string()).optional().allow("", null),
-      endDate: import_joi10.default.alternatives().try(import_joi10.default.date(), import_joi10.default.string()).optional().allow("", null),
-      site: import_joi10.default.string().hex().optional().allow("", null)
-    });
-    const { error } = validation.validate(query);
-    if (error) {
-      next(new import_node_server_utils19.BadRequestError(error.message));
-      return;
-    }
-    const page = parseInt(req.query.page) ?? 1;
-    const limit = parseInt(req.query.limit) ?? 20;
-    const search = req.query.search ?? "";
-    const site = req.query.site ?? "";
-    const startDate = req.query.startDate ?? "";
-    const endDate = req.query.endDate ?? "";
-    try {
-      const data = await _getAll({
-        page,
-        limit,
-        search,
-        site,
-        startDate,
-        endDate
-      });
-      res.json(data);
-      return;
-    } catch (error2) {
-      next(error2);
-      return;
-    }
-  }
-  async function createScheduleTaskArea(req, res, next) {
-    const cookies = req.headers.cookie ? req.headers.cookie.split(";").map((cookie) => cookie.trim().split("=")).reduce(
-      (acc, [key, value]) => ({ ...acc, [key]: value }),
-      {}
-    ) : {};
-    const createdBy = cookies["user"] || "";
-    const payload = { ...req.body, createdBy };
-    const { error } = scheduleTaskAreaSchema.validate(payload);
-    if (error) {
-      import_node_server_utils19.logger.log({ level: "error", message: error.message });
-      next(new import_node_server_utils19.BadRequestError(error.message));
-      return;
-    }
-    try {
-      const id = await _createScheduleTaskArea(payload);
-      res.status(201).json({ message: "Area created successfully.", id });
-      return;
-    } catch (error2) {
-      import_node_server_utils19.logger.log({ level: "error", message: error2.message });
-      next(error2);
-      return;
-    }
-  }
-  async function updateScheduleTaskArea(req, res, next) {
-    const payload = { id: req.params.id, ...req.body };
-    const schema = import_joi10.default.object({
-      id: import_joi10.default.string().hex().required(),
-      name: import_joi10.default.string().required()
-    });
-    const { error } = schema.validate(payload);
-    if (error) {
-      next(new import_node_server_utils19.BadRequestError(error.message));
-      import_node_server_utils19.logger.info(`Controller: ${error.message}`);
-      return;
-    }
-    try {
-      const { id, ...value } = payload;
-      await _updateScheduleTaskArea(id, value);
-      res.json({ message: "Area updated successfully." });
-      return;
-    } catch (error2) {
-      import_node_server_utils19.logger.log({ level: "error", message: error2.message });
-      next(error2);
-      return;
-    }
-  }
-  async function deleteScheduleTaskArea(req, res, next) {
-    const id = req.params.id;
-    const validation = import_joi10.default.object({
-      id: import_joi10.default.string().hex().required()
-    });
-    const { error } = validation.validate({ id });
-    if (error) {
-      import_node_server_utils19.logger.log({ level: "error", message: error.message });
-      next(new import_node_server_utils19.BadRequestError(error.message));
-      return;
-    }
-    try {
-      await _deleteById(id);
-      res.json({ message: "Area deleted successfully." });
-      return;
-    } catch (error2) {
-      import_node_server_utils19.logger.log({ level: "error", message: error2.message });
-      next(error2);
-      return;
-    }
-  }
-  async function uploadByFile(req, res, next) {
-    if (!req.file) {
-      next(new import_node_server_utils19.BadRequestError("File is required!"));
-      return;
-    }
-    const cookies = req.headers.cookie ? req.headers.cookie.split(";").map((cookie) => cookie.trim().split("=")).reduce(
-      (acc, [key, value]) => ({ ...acc, [key]: value }),
-      {}
-    ) : {};
-    const createdBy = cookies["user"] || "";
-    const { site } = req.body;
-    const schema = import_joi10.default.object({
-      site: import_joi10.default.string().hex().optional().allow("", null),
-      createdBy: import_joi10.default.string().hex().required()
-    });
-    const { error } = schema.validate({ site, createdBy });
-    if (error) {
-      import_node_server_utils19.logger.log({ level: "error", message: error.message });
-      next(new import_node_server_utils19.BadRequestError(error.message));
-      return;
-    }
-    try {
-      const xlsData = await convertBufferFile(req.file.buffer);
-      const dataJson = JSON.stringify(xlsData);
-      const result = await _uploadByFile({ dataJson, createdBy, site });
-      return res.status(201).json(result);
-    } catch (error2) {
-      import_node_server_utils19.logger.log({ level: "error", message: error2.message });
-      next(error2);
-      return;
-    }
-  }
-  async function getAreaById(req, res, next) {
-    const validation = import_joi10.default.string().hex().required();
-    const _id = req.params.id;
-    const { error } = validation.validate(_id);
-    if (error) {
-      import_node_server_utils19.logger.log({ level: "error", message: error.message });
-      next(new import_node_server_utils19.BadRequestError(error.message));
-      return;
-    }
+    const page = parseInt(req.query.page) ?? 1;
+    const limit = parseInt(req.query.limit) ?? 20;
+    const search = req.query.search ?? "";
+    const site = req.params.site ?? "";
+    const startDate = req.query.startDate ?? "";
+    const endDate = req.query.endDate ?? "";
     try {
-      const data = await _getAreaById(_id);
+      const data = await _getAllParentChecklist({
+        page,
+        limit,
+        search,
+        site,
+        startDate,
+        endDate
+      });
       res.json(data);
       return;
     } catch (error2) {
-      import_node_server_utils19.logger.log({ level: "error", message: error2.message });
+      import_node_server_utils11.logger.log({ level: "error", message: error2.message });
       next(error2);
       return;
     }
   }
   return {
-    getAll,
-    getAreaById,
-    createScheduleTaskArea,
-    updateScheduleTaskArea,
-    deleteScheduleTaskArea,
-    uploadByFile
+    createParentChecklist,
+    getAllParentChecklist
   };
 }
 
 // src/models/hygiene-area-checklist.model.ts
-var import_node_server_utils20 = require("@iservice365/node-server-utils");
-var import_joi11 = __toESM(require("joi"));
-var import_mongodb11 = require("mongodb");
-var areaChecklistSchema = import_joi11.default.object({
-  type: import_joi11.default.string().required().valid(...allowedTypes),
-  site: import_joi11.default.string().hex().required(),
-  parentChecklist: import_joi11.default.string().hex().required(),
-  area: import_joi11.default.string().hex().required(),
-  name: import_joi11.default.string().optional().allow("", null),
-  createdBy: import_joi11.default.string().hex().optional().allow("", null)
+var import_node_server_utils12 = require("@iservice365/node-server-utils");
+var import_joi7 = __toESM(require("joi"));
+var import_mongodb7 = require("mongodb");
+var allowedChecklistStatus = ["ready", "completed"];
+var areaChecklistSchema = import_joi7.default.object({
+  schedule: import_joi7.default.string().hex().required(),
+  name: import_joi7.default.string().required(),
+  type: import_joi7.default.string().valid(...allowedTypes).required(),
+  checklist: import_joi7.default.array().items(
+    import_joi7.default.object({
+      set: import_joi7.default.number().min(0).required(),
+      units: import_joi7.default.array().items(
+        import_joi7.default.object({
+          name: import_joi7.default.string().required()
+        }).required()
+      ).min(1).required()
+    }).required()
+  ).optional().default([])
 });
 function MAreaChecklist(value) {
   const { error } = areaChecklistSchema.validate(value);
   if (error) {
-    import_node_server_utils20.logger.info(`Hygiene Checklist Area Model: ${error.message}`);
-    throw new import_node_server_utils20.BadRequestError(error.message);
-  }
-  if (value.site) {
-    try {
-      value.site = new import_mongodb11.ObjectId(value.site);
-    } catch (error2) {
-      throw new import_node_server_utils20.BadRequestError("Invalid site ID format.");
-    }
-  }
-  if (value.parentChecklist) {
-    try {
-      value.parentChecklist = new import_mongodb11.ObjectId(value.parentChecklist);
-    } catch (error2) {
-      throw new import_node_server_utils20.BadRequestError("Invalid checklist ID format.");
-    }
-  }
-  if (value.area) {
-    try {
-      value.area = new import_mongodb11.ObjectId(value.area);
-    } catch (error2) {
-      throw new import_node_server_utils20.BadRequestError("Invalid area ID format.");
-    }
+    import_node_server_utils12.logger.info(`Hygiene Checklist Area Model: ${error.message}`);
+    throw new import_node_server_utils12.BadRequestError(error.message);
   }
-  if (value.createdBy) {
+  if (value.schedule) {
     try {
-      value.createdBy = new import_mongodb11.ObjectId(value.createdBy);
+      value.schedule = new import_mongodb7.ObjectId(value.schedule);
     } catch (error2) {
-      throw new import_node_server_utils20.BadRequestError("Invalid createdBy ID format.");
+      throw new import_node_server_utils12.BadRequestError("Invalid schedule ID format.");
     }
   }
-  if (value.acceptedBy) {
-    try {
-      value.acceptedBy = new import_mongodb11.ObjectId(value.acceptedBy);
-    } catch (error2) {
-      throw new import_node_server_utils20.BadRequestError("Invalid acceptedBy ID format.");
-    }
+  if (value.checklist && Array.isArray(value.checklist)) {
+    value.checklist = value.checklist.map((checklistItem) => {
+      return {
+        set: checklistItem.set,
+        units: checklistItem.units.map((unit) => ({
+          name: unit.name,
+          status: "ready",
+          remarks: "",
+          timestamp: ""
+        }))
+      };
+    });
   }
   return {
+    schedule: value.schedule,
+    name: value.name,
     type: value.type,
-    site: value.site,
-    parentChecklist: value.parentChecklist,
-    area: value.area,
-    name: value.name ?? "",
-    status: value.status ?? "To Do",
-    createdBy: value.createdBy ?? "",
+    checklist: value.checklist || [],
+    status: "ready",
     createdAt: /* @__PURE__ */ new Date(),
-    acceptedBy: value.acceptedBy ?? "",
-    acceptedAt: value.acceptedAt ?? "",
-    startedAt: value.startedAt ?? "",
-    endedAt: value.endedAt ?? "",
-    signature: value.signature ?? "",
-    updatedAt: value.updatedAt ?? ""
+    updatedAt: ""
   };
 }
 
 // src/repositories/hygiene-area-checklist.repository.ts
-var import_node_server_utils21 = require("@iservice365/node-server-utils");
-var import_mongodb12 = require("mongodb");
+var import_node_server_utils13 = require("@iservice365/node-server-utils");
+var import_mongodb8 = require("mongodb");
 function useAreaChecklistRepo() {
-  const db = import_node_server_utils21.useAtlas.getDb();
+  const db = import_node_server_utils13.useAtlas.getDb();
   if (!db) {
-    throw new import_node_server_utils21.InternalServerError("Unable to connect to server.");
+    throw new import_node_server_utils13.InternalServerError("Unable to connect to server.");
   }
-  const namespace_collection = "hygiene-checklist.areas";
-  const unit_checklist_collection = "hygiene-checklist.units";
+  const namespace_collection = "site.cleaning.schedule.areas";
+  const unit_checklist_collection = "site.cleaning.schedule.units";
   const collection = db.collection(namespace_collection);
   const unitChecklistCollection = db.collection(unit_checklist_collection);
-  const { delNamespace, setCache, getCache } = (0, import_node_server_utils21.useCache)(namespace_collection);
-  const { delNamespace: delUnitNamespace } = (0, import_node_server_utils21.useCache)(
+  const { delNamespace, setCache, getCache } = (0, import_node_server_utils13.useCache)(namespace_collection);
+  const { delNamespace: delUnitNamespace } = (0, import_node_server_utils13.useCache)(
     unit_checklist_collection
   );
   async function createIndex() {
     try {
       await collection.createIndexes([
+        { key: { schedule: 1 } },
         { key: { type: 1 } },
-        { key: { site: 1 } },
-        { key: { parentChecklist: 1 } },
-        { key: { area: 1 } },
+        { key: { status: 1 } },
         { key: { createdAt: 1 } },
         { key: { acceptedBy: 1 } }
       ]);
     } catch (error) {
-      throw new import_node_server_utils21.InternalServerError(
+      throw new import_node_server_utils13.InternalServerError(
         "Failed to create index on hygiene checklist area."
       );
     }
@@ -3217,16 +1829,14 @@ function useAreaChecklistRepo() {
     try {
       await collection.createIndex({ name: "text" });
     } catch (error) {
-      throw new import_node_server_utils21.InternalServerError(
+      throw new import_node_server_utils13.InternalServerError(
         "Failed to create text index on hygiene checklist area."
       );
     }
   }
   async function createAreaChecklist(value, session) {
     try {
-      const siteId = new import_mongodb12.ObjectId(value.site);
-      const parentChecklistId = new import_mongodb12.ObjectId(value.parentChecklist);
-      const areaId = new import_mongodb12.ObjectId(value.area);
+      const parentChecklistId = new import_mongodb8.ObjectId(value.schedule);
       const currentDate = /* @__PURE__ */ new Date();
       const startOfDay = new Date(currentDate);
       startOfDay.setUTCHours(0, 0, 0, 0);
@@ -3234,26 +1844,25 @@ function useAreaChecklistRepo() {
       endOfDay.setUTCHours(23, 59, 59, 999);
       const existingChecklist = await collection.findOne({
         type: value.type,
-        site: siteId,
-        parentChecklist: parentChecklistId,
-        area: areaId,
+        schedule: parentChecklistId,
+        name: value.name,
         createdAt: {
           $gte: startOfDay,
           $lte: endOfDay
         }
       });
       if (existingChecklist) {
-        import_node_server_utils21.logger.info(
-          `Area checklist already exists for area ${areaId} on ${currentDate.toISOString().split("T")[0]}`
+        import_node_server_utils13.logger.info(
+          `Area checklist already exists for area ${value.name} on ${currentDate.toISOString().split("T")[0]}`
         );
         return existingChecklist._id;
       }
       const processedValue = MAreaChecklist(value);
       const result = await collection.insertOne(processedValue, { session });
       delNamespace().then(() => {
-        import_node_server_utils21.logger.info(`Cache cleared for namespace: ${namespace_collection}`);
+        import_node_server_utils13.logger.info(`Cache cleared for namespace: ${namespace_collection}`);
       }).catch((err) => {
-        import_node_server_utils21.logger.error(
+        import_node_server_utils13.logger.error(
           `Failed to clear cache for namespace: ${namespace_collection}`,
           err
         );
@@ -3267,62 +1876,62 @@ function useAreaChecklistRepo() {
     page = 1,
     limit = 10,
     search = "",
-    site,
     type,
-    parentChecklist
+    schedule
   }) {
     page = page > 0 ? page - 1 : 0;
-    const query = { type };
+    const query = {};
     const cacheOptions = {
       page,
       limit
     };
     try {
-      query.site = new import_mongodb12.ObjectId(site);
-      cacheOptions.site = site.toString();
+      query.schedule = new import_mongodb8.ObjectId(schedule);
+      cacheOptions.schedule = schedule.toString();
     } catch (error) {
-      throw new import_node_server_utils21.BadRequestError("Invalid site ID format.");
+      throw new import_node_server_utils13.BadRequestError("Invalid parent checklist ID format.");
     }
-    try {
-      query.parentChecklist = new import_mongodb12.ObjectId(parentChecklist);
-      cacheOptions.parentChecklist = parentChecklist.toString();
-    } catch (error) {
-      throw new import_node_server_utils21.BadRequestError("Invalid parent checklist ID format.");
+    if (type) {
+      query.type = type;
+      cacheOptions.type = type;
     }
     if (search) {
       query.$text = { $search: search };
       cacheOptions.search = search;
     }
-    const cacheKey = (0, import_node_server_utils21.makeCacheKey)(namespace_collection, cacheOptions);
+    const cacheKey = (0, import_node_server_utils13.makeCacheKey)(namespace_collection, cacheOptions);
     const cachedData = await getCache(cacheKey);
     if (cachedData) {
-      import_node_server_utils21.logger.info(`Cache hit for key: ${cacheKey}`);
+      import_node_server_utils13.logger.info(`Cache hit for key: ${cacheKey}`);
       return cachedData;
     }
     try {
       const pipeline = [
         { $match: query },
-        {
-          $lookup: {
-            from: "users",
-            localField: "acceptedBy",
-            foreignField: "_id",
-            pipeline: [{ $project: { name: 1 } }],
-            as: "acceptedBy"
-          }
-        },
-        {
-          $unwind: {
-            path: "$acceptedBy",
-            preserveNullAndEmptyArrays: true
-          }
-        },
         {
           $project: {
             name: 1,
-            acceptedByName: "$acceptedBy.name",
-            status: 1,
-            createdAt: 1
+            status: {
+              $switch: {
+                branches: [
+                  { case: { $eq: ["$status", "ready"] }, then: "Ready" },
+                  { case: { $eq: ["$status", "ongoing"] }, then: "Ongoing" },
+                  {
+                    case: { $eq: ["$status", "completed"] },
+                    then: "Completed"
+                  }
+                ],
+                default: "$status"
+              }
+            },
+            type: 1,
+            set: {
+              $cond: {
+                if: { $gt: [{ $size: { $ifNull: ["$checklist", []] } }, 0] },
+                then: { $max: "$checklist.set" },
+                else: 0
+              }
+            }
           }
         },
         { $sort: { _id: -1 } },
@@ -3331,11 +1940,11 @@ function useAreaChecklistRepo() {
       ];
       const items = await collection.aggregate(pipeline).toArray();
       const length = await collection.countDocuments(query);
-      const data = (0, import_node_server_utils21.paginate)(items, page, limit, length);
+      const data = (0, import_node_server_utils13.paginate)(items, page, limit, length);
       setCache(cacheKey, data, 15 * 60).then(() => {
-        import_node_server_utils21.logger.info(`Cache set for key: ${cacheKey}`);
+        import_node_server_utils13.logger.info(`Cache set for key: ${cacheKey}`);
       }).catch((err) => {
-        import_node_server_utils21.logger.error(`Failed to set cache for key: ${cacheKey}`, err);
+        import_node_server_utils13.logger.error(`Failed to set cache for key: ${cacheKey}`, err);
       });
       return data;
     } catch (error) {
@@ -3348,7 +1957,7 @@ function useAreaChecklistRepo() {
     search = "",
     site,
     type,
-    parentChecklist,
+    schedule,
     status,
     createdAt,
     user
@@ -3360,16 +1969,16 @@ function useAreaChecklistRepo() {
       limit
     };
     try {
-      query.site = new import_mongodb12.ObjectId(site);
+      query.site = new import_mongodb8.ObjectId(site);
       cacheOptions.site = site.toString();
     } catch (error) {
-      throw new import_node_server_utils21.BadRequestError("Invalid site ID format.");
+      throw new import_node_server_utils13.BadRequestError("Invalid site ID format.");
     }
     try {
-      query.parentChecklist = new import_mongodb12.ObjectId(parentChecklist);
-      cacheOptions.parentChecklist = parentChecklist.toString();
+      query.schedule = new import_mongodb8.ObjectId(schedule);
+      cacheOptions.schedule = schedule.toString();
     } catch (error) {
-      throw new import_node_server_utils21.BadRequestError("Invalid parent checklist ID format.");
+      throw new import_node_server_utils13.BadRequestError("Invalid parent checklist ID format.");
     }
     if (search) {
       query.$text = { $search: search };
@@ -3386,20 +1995,20 @@ function useAreaChecklistRepo() {
       query.status = status;
       cacheOptions.status = status;
     } else {
-      query.status = { $in: ["In Progress", "Completed"] };
+      query.status = { $in: ["ongoing", "completed"] };
     }
     if (user) {
       try {
-        query.acceptedBy = new import_mongodb12.ObjectId(user);
+        query.acceptedBy = new import_mongodb8.ObjectId(user);
         cacheOptions.user = user.toString();
       } catch (error) {
-        throw new import_node_server_utils21.BadRequestError("Invalid user ID format.");
+        throw new import_node_server_utils13.BadRequestError("Invalid user ID format.");
       }
     }
-    const cacheKey = (0, import_node_server_utils21.makeCacheKey)(namespace_collection, cacheOptions);
+    const cacheKey = (0, import_node_server_utils13.makeCacheKey)(namespace_collection, cacheOptions);
     const cachedData = await getCache(cacheKey);
     if (cachedData) {
-      import_node_server_utils21.logger.info(`Cache hit for key: ${cacheKey}`);
+      import_node_server_utils13.logger.info(`Cache hit for key: ${cacheKey}`);
       return cachedData;
     }
     try {
@@ -3428,9 +2037,21 @@ function useAreaChecklistRepo() {
             name: 1,
             createdAt: 1,
             acceptedByName: "$acceptedBy.name",
-            status: 1,
-            startedAt: 1,
-            endedAt: 1
+            status: {
+              $switch: {
+                branches: [
+                  { case: { $eq: ["$status", "ready"] }, then: "Ready" },
+                  { case: { $eq: ["$status", "ongoing"] }, then: "Ongoing" },
+                  {
+                    case: { $eq: ["$status", "completed"] },
+                    then: "Completed"
+                  }
+                ],
+                default: "$status"
+              }
+            },
+            startedAt: "$acceptedAt",
+            endedAt: "$completedAt"
           }
         },
         { $sort: { status: 1 } },
@@ -3439,11 +2060,11 @@ function useAreaChecklistRepo() {
       ];
       const items = await collection.aggregate(pipeline).toArray();
       const length = await collection.countDocuments(query);
-      const data = (0, import_node_server_utils21.paginate)(items, page, limit, length);
+      const data = (0, import_node_server_utils13.paginate)(items, page, limit, length);
       setCache(cacheKey, data, 15 * 60).then(() => {
-        import_node_server_utils21.logger.info(`Cache set for key: ${cacheKey}`);
+        import_node_server_utils13.logger.info(`Cache set for key: ${cacheKey}`);
       }).catch((err) => {
-        import_node_server_utils21.logger.error(`Failed to set cache for key: ${cacheKey}`, err);
+        import_node_server_utils13.logger.error(`Failed to set cache for key: ${cacheKey}`, err);
       });
       return data;
     } catch (error) {
@@ -3452,16 +2073,16 @@ function useAreaChecklistRepo() {
   }
   async function getAreaChecklistHistoryDetails(_id) {
     try {
-      _id = new import_mongodb12.ObjectId(_id);
+      _id = new import_mongodb8.ObjectId(_id);
     } catch (error) {
-      throw new import_node_server_utils21.BadRequestError("Invalid area checklist ID format.");
+      throw new import_node_server_utils13.BadRequestError("Invalid area checklist ID format.");
     }
-    const cacheKey = (0, import_node_server_utils21.makeCacheKey)(namespace_collection, {
+    const cacheKey = (0, import_node_server_utils13.makeCacheKey)(namespace_collection, {
       _id: _id.toString()
     });
     const cachedData = await getCache(cacheKey);
     if (cachedData) {
-      import_node_server_utils21.logger.info(`Cache hit for key: ${cacheKey}`);
+      import_node_server_utils13.logger.info(`Cache hit for key: ${cacheKey}`);
       return cachedData;
     }
     try {
@@ -3502,9 +2123,21 @@ function useAreaChecklistRepo() {
             name: 1,
             createdAt: 1,
             createdByName: "$createdBy.name",
-            startedAt: 1,
-            endedAt: 1,
-            status: 1,
+            startedAt: "$acceptedAt",
+            endedAt: "$completedAt",
+            status: {
+              $switch: {
+                branches: [
+                  { case: { $eq: ["$status", "ready"] }, then: "Ready" },
+                  { case: { $eq: ["$status", "ongoing"] }, then: "Ongoing" },
+                  {
+                    case: { $eq: ["$status", "completed"] },
+                    then: "Completed"
+                  }
+                ],
+                default: "$status"
+              }
+            },
             signature: 1,
             acceptedByName: "$acceptedBy.name"
           }
@@ -3527,16 +2160,16 @@ function useAreaChecklistRepo() {
         unitChecklistCollection.aggregate(unitPipeline).toArray()
       ]);
       if (!area.length) {
-        throw new import_node_server_utils21.BadRequestError("Area checklist not found.");
+        throw new import_node_server_utils13.BadRequestError("Area checklist not found.");
       }
       const items = {
         area: area[0],
         units
       };
       setCache(cacheKey, items, 15 * 60).then(() => {
-        import_node_server_utils21.logger.info(`Cache set for key: ${cacheKey}`);
+        import_node_server_utils13.logger.info(`Cache set for key: ${cacheKey}`);
       }).catch((err) => {
-        import_node_server_utils21.logger.error(`Failed to set cache for key: ${cacheKey}`, err);
+        import_node_server_utils13.logger.error(`Failed to set cache for key: ${cacheKey}`, err);
       });
       return items;
     } catch (error) {
@@ -3545,31 +2178,32 @@ function useAreaChecklistRepo() {
   }
   async function acceptAreaChecklist(_id, acceptedBy) {
     try {
-      _id = new import_mongodb12.ObjectId(_id);
+      _id = new import_mongodb8.ObjectId(_id);
     } catch (error) {
-      throw new import_node_server_utils21.BadRequestError("Invalid area ID format.");
+      throw new import_node_server_utils13.BadRequestError("Invalid area ID format.");
     }
     try {
-      acceptedBy = new import_mongodb12.ObjectId(acceptedBy);
+      acceptedBy = new import_mongodb8.ObjectId(acceptedBy);
     } catch (error) {
-      throw new import_node_server_utils21.BadRequestError("Invalid acceptedBy ID format.");
+      throw new import_node_server_utils13.BadRequestError("Invalid acceptedBy ID format.");
     }
     try {
       const now = /* @__PURE__ */ new Date();
       const updateValue = {
-        acceptedBy,
-        acceptedAt: now,
-        startedAt: now,
+        metadata: {
+          acceptedBy,
+          acceptedAt: now
+        },
         updatedAt: now
       };
       const res = await collection.updateOne({ _id }, { $set: updateValue });
       if (res.modifiedCount === 0) {
-        throw new import_node_server_utils21.InternalServerError("Unable to update cleaning area.");
+        throw new import_node_server_utils13.InternalServerError("Unable to update cleaning area.");
       }
       delNamespace().then(() => {
-        import_node_server_utils21.logger.info(`Cache cleared for namespace: ${namespace_collection}`);
+        import_node_server_utils13.logger.info(`Cache cleared for namespace: ${namespace_collection}`);
       }).catch((err) => {
-        import_node_server_utils21.logger.error(
+        import_node_server_utils13.logger.error(
           `Failed to clear cache for namespace: ${namespace_collection}`,
           err
         );
@@ -3581,9 +2215,9 @@ function useAreaChecklistRepo() {
   }
   async function attachImageAreaChecklist(_id, attachments, session) {
     try {
-      _id = new import_mongodb12.ObjectId(_id);
+      _id = new import_mongodb8.ObjectId(_id);
     } catch (error) {
-      throw new import_node_server_utils21.BadRequestError("Invalid area checklist ID format.");
+      throw new import_node_server_utils13.BadRequestError("Invalid area checklist ID format.");
     }
     try {
       const now = /* @__PURE__ */ new Date();
@@ -3597,24 +2231,24 @@ function useAreaChecklistRepo() {
         { session }
       );
       if (res.modifiedCount === 0) {
-        throw new import_node_server_utils21.InternalServerError(
+        throw new import_node_server_utils13.InternalServerError(
           "Unable to update cleaning area checklist."
         );
       }
       delNamespace().then(() => {
-        import_node_server_utils21.logger.info(`Cache cleared for namespace: ${namespace_collection}`);
+        import_node_server_utils13.logger.info(`Cache cleared for namespace: ${namespace_collection}`);
       }).catch((err) => {
-        import_node_server_utils21.logger.error(
+        import_node_server_utils13.logger.error(
           `Failed to clear cache for namespace: ${namespace_collection}`,
           err
         );
       });
       delUnitNamespace().then(() => {
-        import_node_server_utils21.logger.info(
+        import_node_server_utils13.logger.info(
           `Cache cleared for namespace: ${unit_checklist_collection}`
         );
       }).catch((err) => {
-        import_node_server_utils21.logger.error(
+        import_node_server_utils13.logger.error(
           `Failed to clear cache for namespace: ${unit_checklist_collection}`,
           err
         );
@@ -3626,26 +2260,28 @@ function useAreaChecklistRepo() {
   }
   async function submitAreaChecklist(_id, signature) {
     try {
-      _id = new import_mongodb12.ObjectId(_id);
+      _id = new import_mongodb8.ObjectId(_id);
     } catch (error) {
-      throw new import_node_server_utils21.BadRequestError("Invalid area ID format.");
+      throw new import_node_server_utils13.BadRequestError("Invalid area ID format.");
     }
     try {
       const now = /* @__PURE__ */ new Date();
       const updateValue = {
-        signature,
-        status: "In Progress",
-        endedAt: now,
+        metadata: {
+          signature,
+          completedAt: now
+        },
+        status: "ongoing",
         updatedAt: now
       };
       const res = await collection.updateOne({ _id }, { $set: updateValue });
       if (res.modifiedCount === 0) {
-        throw new import_node_server_utils21.InternalServerError("Unable to update cleaning area.");
+        throw new import_node_server_utils13.InternalServerError("Unable to update cleaning area.");
       }
       delNamespace().then(() => {
-        import_node_server_utils21.logger.info(`Cache cleared for namespace: ${namespace_collection}`);
+        import_node_server_utils13.logger.info(`Cache cleared for namespace: ${namespace_collection}`);
       }).catch((err) => {
-        import_node_server_utils21.logger.error(
+        import_node_server_utils13.logger.error(
           `Failed to clear cache for namespace: ${namespace_collection}`,
           err
         );
@@ -3657,26 +2293,28 @@ function useAreaChecklistRepo() {
   }
   async function completeAreaChecklist(_id, signature) {
     try {
-      _id = new import_mongodb12.ObjectId(_id);
+      _id = new import_mongodb8.ObjectId(_id);
     } catch (error) {
-      throw new import_node_server_utils21.BadRequestError("Invalid area ID format.");
+      throw new import_node_server_utils13.BadRequestError("Invalid area ID format.");
     }
     try {
       const now = /* @__PURE__ */ new Date();
       const updateValue = {
-        signature,
-        status: "Completed",
-        endedAt: now,
+        metadata: {
+          signature,
+          completedAt: now
+        },
+        status: "completed",
         updatedAt: now
       };
       const res = await collection.updateOne({ _id }, { $set: updateValue });
       if (res.modifiedCount === 0) {
-        throw new import_node_server_utils21.InternalServerError("Unable to update cleaning area.");
+        throw new import_node_server_utils13.InternalServerError("Unable to update cleaning area.");
       }
       delNamespace().then(() => {
-        import_node_server_utils21.logger.info(`Cache cleared for namespace: ${namespace_collection}`);
+        import_node_server_utils13.logger.info(`Cache cleared for namespace: ${namespace_collection}`);
       }).catch((err) => {
-        import_node_server_utils21.logger.error(
+        import_node_server_utils13.logger.error(
           `Failed to clear cache for namespace: ${namespace_collection}`,
           err
         );
@@ -3701,72 +2339,110 @@ function useAreaChecklistRepo() {
 }
 
 // src/controllers/hygiene-area-checklist.controller.ts
-var import_node_server_utils23 = require("@iservice365/node-server-utils");
-var import_joi12 = __toESM(require("joi"));
+var import_node_server_utils15 = require("@iservice365/node-server-utils");
+var import_joi8 = __toESM(require("joi"));
 
 // src/services/hygiene-area-checklist.service.ts
-var import_node_server_utils22 = require("@iservice365/node-server-utils");
+var import_node_server_utils14 = require("@iservice365/node-server-utils");
 function useAreaChecklistService() {
   const { createAreaChecklist: _createAreaChecklist } = useAreaChecklistRepo();
-  const { getAreas } = useAreaRepository();
-  const { getToiletLocations } = useToiletLocationRepository();
+  const { getAreasForChecklist } = useAreaRepo();
   async function createAreaChecklist(value) {
+    const session = import_node_server_utils14.useAtlas.getClient()?.startSession();
     try {
+      session?.startTransaction();
       const results = [];
-      if (value.type === "cleaner") {
-        const cleanerAreasResult = await getAreas({
-          site: value.site
-        });
-        const cleanerAreas = cleanerAreasResult.items || [];
-        if (cleanerAreas.length === 0) {
-          import_node_server_utils22.logger.warn(`No cleaner areas found for site: ${value.site}`);
-          return results;
-        }
-        for (const area of cleanerAreas) {
-          const checklistData = {
-            type: "cleaner",
-            site: value.site,
-            parentChecklist: value.parentChecklist,
-            area: area._id.toString(),
-            name: area.name,
-            createdBy: value.createdBy
-          };
-          const insertedId = await _createAreaChecklist(checklistData);
-          results.push(insertedId);
+      let totalChecklistsCreated = 0;
+      const BATCH_SIZE = 10;
+      const commonAreasResult = await getAreasForChecklist({
+        site: value.site,
+        type: "common"
+      });
+      const commonAreas = commonAreasResult || [];
+      if (commonAreas.length > 0) {
+        for (let i = 0; i < commonAreas.length; i += BATCH_SIZE) {
+          const batch = commonAreas.slice(i, i + BATCH_SIZE);
+          const batchPromises = batch.map(async (area) => {
+            const checklistData = {
+              schedule: value.schedule,
+              name: area.name,
+              type: "common",
+              checklist: area.units && area.units.length > 0 ? [
+                {
+                  set: area.set || 0,
+                  units: area.units.map((unit) => ({
+                    name: unit.name
+                  }))
+                }
+              ] : []
+            };
+            const insertedId = await _createAreaChecklist(
+              checklistData,
+              session
+            );
+            totalChecklistsCreated++;
+            return insertedId;
+          });
+          const batchResults = await Promise.all(batchPromises);
+          results.push(...batchResults);
         }
-        import_node_server_utils22.logger.info(
-          `Created ${results.length} cleaner area checklists for site: ${value.site}`
+        import_node_server_utils14.logger.info(
+          `Created ${commonAreas.length} common area checklists for site: ${value.site}`
         );
+      } else {
+        import_node_server_utils14.logger.warn(`No common areas found for site: ${value.site}`);
       }
-      if (value.type === "toilet") {
-        const toiletAreasResult = await getToiletLocations({
-          site: value.site
-        });
-        const toiletAreas = toiletAreasResult.items || [];
-        if (toiletAreas.length === 0) {
-          import_node_server_utils22.logger.warn(`No toilet locations found for site: ${value.site}`);
-          return results;
-        }
-        for (const toiletLocation of toiletAreas) {
-          const checklistData = {
-            type: "toilet",
-            site: value.site,
-            parentChecklist: value.parentChecklist,
-            area: toiletLocation._id,
-            name: toiletLocation.name,
-            createdBy: value.createdBy
-          };
-          const insertedId = await _createAreaChecklist(checklistData);
-          results.push(insertedId);
+      const toiletAreasResult = await getAreasForChecklist({
+        site: value.site,
+        type: "toilet"
+      });
+      const toiletAreas = toiletAreasResult || [];
+      if (toiletAreas.length > 0) {
+        for (let i = 0; i < toiletAreas.length; i += BATCH_SIZE) {
+          const batch = toiletAreas.slice(i, i + BATCH_SIZE);
+          const batchPromises = batch.map(async (toiletLocation) => {
+            const checklistData = {
+              schedule: value.schedule,
+              name: toiletLocation.name,
+              type: "toilet",
+              checklist: toiletLocation.units && toiletLocation.units.length > 0 ? [
+                {
+                  set: toiletLocation.set || 0,
+                  units: toiletLocation.units.map((unit) => ({
+                    name: unit.name
+                  }))
+                }
+              ] : []
+            };
+            const insertedId = await _createAreaChecklist(
+              checklistData,
+              session
+            );
+            totalChecklistsCreated++;
+            return insertedId;
+          });
+          const batchResults = await Promise.all(batchPromises);
+          results.push(...batchResults);
         }
-        import_node_server_utils22.logger.info(
-          `Created ${results.length} toilet area checklists for site: ${value.site}`
+        import_node_server_utils14.logger.info(
+          `Created ${toiletAreas.length} toilet area checklists for site: ${value.site}`
         );
+      } else {
+        import_node_server_utils14.logger.warn(`No toilet locations found for site: ${value.site}`);
       }
+      await session?.commitTransaction();
+      import_node_server_utils14.logger.info(
+        `Successfully created ${totalChecklistsCreated} area checklists for site: ${value.site}`
+      );
       return results;
     } catch (error) {
-      import_node_server_utils22.logger.error(`Error generating area checklists:`, error);
+      import_node_server_utils14.logger.error(`Error generating area checklists:`, error);
+      if (session?.inTransaction()) {
+        await session?.abortTransaction();
+      }
       throw error;
+    } finally {
+      session?.endSession();
     }
   }
   return { createAreaChecklist };
@@ -3785,69 +2461,62 @@ function useAreaChecklistController() {
   } = useAreaChecklistRepo();
   const { createAreaChecklist: _createAreaChecklist } = useAreaChecklistService();
   async function createAreaChecklist(req, res, next) {
-    const cookies = req.headers.cookie ? req.headers.cookie.split(";").map((cookie) => cookie.trim().split("=")).reduce(
-      (acc, [key, value]) => ({ ...acc, [key]: value }),
-      {}
-    ) : {};
-    const createdBy = cookies["user"] || "";
-    const payload = { ...req.body, ...req.params, createdBy };
-    const validation = import_joi12.default.object({
-      type: import_joi12.default.string().required().valid(...allowedTypes),
-      site: import_joi12.default.string().hex().required(),
-      parentChecklist: import_joi12.default.string().hex().required(),
-      createdBy: import_joi12.default.string().hex().optional().allow("", null)
+    const payload = {
+      site: req.params.site,
+      schedule: req.params.schedule
+    };
+    const validation = import_joi8.default.object({
+      site: import_joi8.default.string().hex().required(),
+      schedule: import_joi8.default.string().hex().required()
     });
     const { error } = validation.validate(payload);
     if (error) {
-      import_node_server_utils23.logger.log({ level: "error", message: error.message });
-      next(new import_node_server_utils23.BadRequestError(error.message));
+      import_node_server_utils15.logger.log({ level: "error", message: error.message });
+      next(new import_node_server_utils15.BadRequestError(error.message));
       return;
     }
     try {
       await _createAreaChecklist(payload);
-      res.status(201).json({ message: "Area checklists generated successfully." });
+      res.status(201).json({ message: "Area checklist generated successfully." });
       return;
     } catch (error2) {
-      import_node_server_utils23.logger.log({ level: "error", message: error2.message });
+      import_node_server_utils15.logger.log({ level: "error", message: error2.message });
       next(error2);
       return;
     }
   }
   async function getAllAreaChecklist(req, res, next) {
     const query = { ...req.query, ...req.params };
-    const validation = import_joi12.default.object({
-      page: import_joi12.default.number().min(1).optional().allow("", null),
-      limit: import_joi12.default.number().min(1).optional().allow("", null),
-      search: import_joi12.default.string().optional().allow("", null),
-      site: import_joi12.default.string().hex().required(),
-      type: import_joi12.default.string().valid(...allowedTypes).required(),
-      parentChecklist: import_joi12.default.string().hex().required()
+    const validation = import_joi8.default.object({
+      page: import_joi8.default.number().min(1).optional().allow("", null),
+      limit: import_joi8.default.number().min(1).optional().allow("", null),
+      search: import_joi8.default.string().optional().allow("", null),
+      type: import_joi8.default.string().optional().allow("", ...allowedTypes),
+      schedule: import_joi8.default.string().hex().required()
     });
     const { error } = validation.validate(query);
     if (error) {
-      import_node_server_utils23.logger.log({ level: "error", message: error.message });
-      next(new import_node_server_utils23.BadRequestError(error.message));
+      import_node_server_utils15.logger.log({ level: "error", message: error.message });
+      next(new import_node_server_utils15.BadRequestError(error.message));
       return;
     }
     const page = parseInt(req.query.page) ?? 1;
     const limit = parseInt(req.query.limit) ?? 20;
     const search = req.query.search ?? "";
-    const site = req.params.site ?? "";
-    const type = req.params.type ?? "";
-    const parentChecklist = req.params.parentChecklist ?? "";
+    const type = req.query.type ?? "";
+    const schedule = req.params.schedule ?? "";
     try {
       const data = await _getAllAreaChecklist({
         page,
         limit,
         search,
-        site,
         type,
-        parentChecklist
+        schedule
       });
       res.json(data);
       return;
     } catch (error2) {
-      import_node_server_utils23.logger.log({ level: "error", message: error2.message });
+      import_node_server_utils15.logger.log({ level: "error", message: error2.message });
       next(error2);
       return;
     }
@@ -3859,29 +2528,29 @@ function useAreaChecklistController() {
     ) : {};
     const user = cookies["user"] || "";
     const query = { ...req.query, ...req.params, user };
-    const validation = import_joi12.default.object({
-      page: import_joi12.default.number().min(1).optional().allow("", null),
-      limit: import_joi12.default.number().min(1).optional().allow("", null),
-      search: import_joi12.default.string().optional().allow("", null),
-      site: import_joi12.default.string().hex().required(),
-      type: import_joi12.default.string().valid(...allowedTypes).required(),
-      parentChecklist: import_joi12.default.string().hex().required(),
-      status: import_joi12.default.string().allow("", null, ...allowedStatus),
-      createdAt: import_joi12.default.alternatives().try(import_joi12.default.date(), import_joi12.default.string()).optional().allow("", null),
-      user: import_joi12.default.string().hex().optional().allow("", null)
+    const validation = import_joi8.default.object({
+      page: import_joi8.default.number().min(1).optional().allow("", null),
+      limit: import_joi8.default.number().min(1).optional().allow("", null),
+      search: import_joi8.default.string().optional().allow("", null),
+      site: import_joi8.default.string().hex().required(),
+      type: import_joi8.default.string().valid(...allowedTypes).required(),
+      schedule: import_joi8.default.string().hex().required(),
+      status: import_joi8.default.string().allow("", null, ...allowedStatus),
+      createdAt: import_joi8.default.alternatives().try(import_joi8.default.date(), import_joi8.default.string()).optional().allow("", null),
+      user: import_joi8.default.string().hex().optional().allow("", null)
     });
     const { error } = validation.validate(query);
     if (error) {
-      import_node_server_utils23.logger.log({ level: "error", message: error.message });
-      next(new import_node_server_utils23.BadRequestError(error.message));
+      import_node_server_utils15.logger.log({ level: "error", message: error.message });
+      next(new import_node_server_utils15.BadRequestError(error.message));
       return;
     }
     const page = parseInt(req.query.page) ?? 1;
     const limit = parseInt(req.query.limit) ?? 20;
     const search = req.query.search ?? "";
     const site = req.params.site ?? "";
-    const type = req.params.type ?? "";
-    const parentChecklist = req.params.parentChecklist ?? "";
+    const type = req.query.type ?? "";
+    const schedule = req.params.schedule ?? "";
     const status = req.query.status ?? "";
     const createdAt = req.query.createdAt ?? "";
     try {
@@ -3891,7 +2560,7 @@ function useAreaChecklistController() {
         search,
         site,
         type,
-        parentChecklist,
+        schedule,
         status,
         createdAt,
         user
@@ -3899,18 +2568,18 @@ function useAreaChecklistController() {
       res.json(data);
       return;
     } catch (error2) {
-      import_node_server_utils23.logger.log({ level: "error", message: error2.message });
+      import_node_server_utils15.logger.log({ level: "error", message: error2.message });
       next(error2);
       return;
     }
   }
   async function getAreaChecklistHistoryDetails(req, res, next) {
-    const validation = import_joi12.default.string().hex().required();
+    const validation = import_joi8.default.string().hex().required();
     const _id = req.params.id;
     const { error } = validation.validate(_id);
     if (error) {
-      import_node_server_utils23.logger.log({ level: "error", message: error.message });
-      next(new import_node_server_utils23.BadRequestError(error.message));
+      import_node_server_utils15.logger.log({ level: "error", message: error.message });
+      next(new import_node_server_utils15.BadRequestError(error.message));
       return;
     }
     try {
@@ -3918,7 +2587,7 @@ function useAreaChecklistController() {
       res.json(data);
       return;
     } catch (error2) {
-      import_node_server_utils23.logger.log({ level: "error", message: error2.message });
+      import_node_server_utils15.logger.log({ level: "error", message: error2.message });
       next(error2);
       return;
     }
@@ -3930,14 +2599,14 @@ function useAreaChecklistController() {
     ) : {};
     const acceptedBy = cookies["user"] || "";
     const payload = { id: req.params.id, acceptedBy };
-    const validation = import_joi12.default.object({
-      id: import_joi12.default.string().hex().required(),
-      acceptedBy: import_joi12.default.string().hex().required()
+    const validation = import_joi8.default.object({
+      id: import_joi8.default.string().hex().required(),
+      acceptedBy: import_joi8.default.string().hex().required()
     });
     const { error } = validation.validate(payload);
     if (error) {
-      import_node_server_utils23.logger.log({ level: "error", message: error.message });
-      next(new import_node_server_utils23.BadRequestError(error.message));
+      import_node_server_utils15.logger.log({ level: "error", message: error.message });
+      next(new import_node_server_utils15.BadRequestError(error.message));
       return;
     }
     try {
@@ -3945,21 +2614,21 @@ function useAreaChecklistController() {
       res.json({ message: "Area checklist updated successfully." });
       return;
     } catch (error2) {
-      import_node_server_utils23.logger.log({ level: "error", message: error2.message });
+      import_node_server_utils15.logger.log({ level: "error", message: error2.message });
       next(error2);
       return;
     }
   }
   async function attachImageAreaChecklist(req, res, next) {
     const payload = { id: req.params.id, attachments: req.body.attachments };
-    const validation = import_joi12.default.object({
-      id: import_joi12.default.string().hex().required(),
-      attachments: import_joi12.default.array().items(import_joi12.default.string()).optional()
+    const validation = import_joi8.default.object({
+      id: import_joi8.default.string().hex().required(),
+      attachments: import_joi8.default.array().items(import_joi8.default.string()).optional()
     });
     const { error } = validation.validate(payload);
     if (error) {
-      import_node_server_utils23.logger.log({ level: "error", message: error.message });
-      next(new import_node_server_utils23.BadRequestError(error.message));
+      import_node_server_utils15.logger.log({ level: "error", message: error.message });
+      next(new import_node_server_utils15.BadRequestError(error.message));
       return;
     }
     try {
@@ -3967,21 +2636,21 @@ function useAreaChecklistController() {
       res.json({ message: "Area checklist attachments updated successfully." });
       return;
     } catch (error2) {
-      import_node_server_utils23.logger.log({ level: "error", message: error2.message });
+      import_node_server_utils15.logger.log({ level: "error", message: error2.message });
       next(error2);
       return;
     }
   }
   async function submitAreaChecklist(req, res, next) {
     const payload = { id: req.params.id, signature: req.body.signature };
-    const validation = import_joi12.default.object({
-      id: import_joi12.default.string().hex().required(),
-      signature: import_joi12.default.string().required()
+    const validation = import_joi8.default.object({
+      id: import_joi8.default.string().hex().required(),
+      signature: import_joi8.default.string().required()
     });
     const { error } = validation.validate(payload);
     if (error) {
-      import_node_server_utils23.logger.log({ level: "error", message: error.message });
-      next(new import_node_server_utils23.BadRequestError(error.message));
+      import_node_server_utils15.logger.log({ level: "error", message: error.message });
+      next(new import_node_server_utils15.BadRequestError(error.message));
       return;
     }
     try {
@@ -3989,21 +2658,21 @@ function useAreaChecklistController() {
       res.json({ message: "Area checklist submitted successfully." });
       return;
     } catch (error2) {
-      import_node_server_utils23.logger.log({ level: "error", message: error2.message });
+      import_node_server_utils15.logger.log({ level: "error", message: error2.message });
       next(error2);
       return;
     }
   }
   async function completeAreaChecklist(req, res, next) {
     const payload = { id: req.params.id, signature: req.body.signature };
-    const validation = import_joi12.default.object({
-      id: import_joi12.default.string().hex().required(),
-      signature: import_joi12.default.string().required()
+    const validation = import_joi8.default.object({
+      id: import_joi8.default.string().hex().required(),
+      signature: import_joi8.default.string().required()
     });
     const { error } = validation.validate(payload);
     if (error) {
-      import_node_server_utils23.logger.log({ level: "error", message: error.message });
-      next(new import_node_server_utils23.BadRequestError(error.message));
+      import_node_server_utils15.logger.log({ level: "error", message: error.message });
+      next(new import_node_server_utils15.BadRequestError(error.message));
       return;
     }
     try {
@@ -4011,7 +2680,7 @@ function useAreaChecklistController() {
       res.json({ message: "Area checklist completed successfully." });
       return;
     } catch (error2) {
-      import_node_server_utils23.logger.log({ level: "error", message: error2.message });
+      import_node_server_utils15.logger.log({ level: "error", message: error2.message });
       next(error2);
       return;
     }
@@ -4029,57 +2698,57 @@ function useAreaChecklistController() {
 }
 
 // src/models/hygiene-unit-checklist.model.ts
-var import_node_server_utils24 = require("@iservice365/node-server-utils");
-var import_joi13 = __toESM(require("joi"));
-var import_mongodb13 = require("mongodb");
-var unitChecklistSchema = import_joi13.default.object({
-  site: import_joi13.default.string().hex().required(),
-  type: import_joi13.default.string().valid(...allowedTypes).required(),
-  parentChecklist: import_joi13.default.string().hex().required(),
-  areaChecklist: import_joi13.default.string().hex().required(),
-  unit: import_joi13.default.string().hex().required(),
-  name: import_joi13.default.string().optional().allow("", null),
-  createdBy: import_joi13.default.string().hex().optional().allow("", null)
+var import_node_server_utils16 = require("@iservice365/node-server-utils");
+var import_joi9 = __toESM(require("joi"));
+var import_mongodb9 = require("mongodb");
+var unitChecklistSchema = import_joi9.default.object({
+  site: import_joi9.default.string().hex().required(),
+  type: import_joi9.default.string().valid(...allowedTypes).required(),
+  parentChecklist: import_joi9.default.string().hex().required(),
+  areaChecklist: import_joi9.default.string().hex().required(),
+  unit: import_joi9.default.string().hex().required(),
+  name: import_joi9.default.string().optional().allow("", null),
+  createdBy: import_joi9.default.string().hex().optional().allow("", null)
 });
 function MUnitChecklist(value) {
   const { error } = unitChecklistSchema.validate(value);
   if (error) {
-    import_node_server_utils24.logger.info(`Hygiene Checklist Unit Model: ${error.message}`);
-    throw new import_node_server_utils24.BadRequestError(error.message);
+    import_node_server_utils16.logger.info(`Hygiene Checklist Unit Model: ${error.message}`);
+    throw new import_node_server_utils16.BadRequestError(error.message);
   }
   if (value.site) {
     try {
-      value.site = new import_mongodb13.ObjectId(value.site);
+      value.site = new import_mongodb9.ObjectId(value.site);
     } catch (error2) {
-      throw new import_node_server_utils24.BadRequestError("Invalid site ID format.");
+      throw new import_node_server_utils16.BadRequestError("Invalid site ID format.");
     }
   }
   if (value.parentChecklist) {
     try {
-      value.parentChecklist = new import_mongodb13.ObjectId(value.parentChecklist);
+      value.parentChecklist = new import_mongodb9.ObjectId(value.parentChecklist);
     } catch (error2) {
-      throw new import_node_server_utils24.BadRequestError("Invalid parent checklist ID format.");
+      throw new import_node_server_utils16.BadRequestError("Invalid parent checklist ID format.");
     }
   }
   if (value.areaChecklist) {
     try {
-      value.areaChecklist = new import_mongodb13.ObjectId(value.areaChecklist);
+      value.areaChecklist = new import_mongodb9.ObjectId(value.areaChecklist);
     } catch (error2) {
-      throw new import_node_server_utils24.BadRequestError("Invalid area checklist ID format.");
+      throw new import_node_server_utils16.BadRequestError("Invalid area checklist ID format.");
     }
   }
   if (value.unit) {
     try {
-      value.unit = new import_mongodb13.ObjectId(value.unit);
+      value.unit = new import_mongodb9.ObjectId(value.unit);
     } catch (error2) {
-      throw new import_node_server_utils24.BadRequestError("Invalid unit ID format.");
+      throw new import_node_server_utils16.BadRequestError("Invalid unit ID format.");
     }
   }
   if (value.createdBy) {
     try {
-      value.createdBy = new import_mongodb13.ObjectId(value.createdBy);
+      value.createdBy = new import_mongodb9.ObjectId(value.createdBy);
     } catch (error2) {
-      throw new import_node_server_utils24.BadRequestError("Invalid createdBy ID format.");
+      throw new import_node_server_utils16.BadRequestError("Invalid createdBy ID format.");
     }
   }
   return {
@@ -4098,16 +2767,16 @@ function MUnitChecklist(value) {
 }
 
 // src/repositories/hygiene-unit-checklist.repository.ts
-var import_node_server_utils25 = require("@iservice365/node-server-utils");
-var import_mongodb14 = require("mongodb");
+var import_node_server_utils17 = require("@iservice365/node-server-utils");
+var import_mongodb10 = require("mongodb");
 function useUnitChecklistRepo() {
-  const db = import_node_server_utils25.useAtlas.getDb();
+  const db = import_node_server_utils17.useAtlas.getDb();
   if (!db) {
-    throw new import_node_server_utils25.InternalServerError("Unable to connect to server.");
+    throw new import_node_server_utils17.InternalServerError("Unable to connect to server.");
   }
   const namespace_collection = "hygiene-checklist.units";
   const collection = db.collection(namespace_collection);
-  const { delNamespace, setCache, getCache } = (0, import_node_server_utils25.useCache)(namespace_collection);
+  const { delNamespace, setCache, getCache } = (0, import_node_server_utils17.useCache)(namespace_collection);
   async function createIndex() {
     try {
       await collection.createIndexes([
@@ -4122,7 +2791,7 @@ function useUnitChecklistRepo() {
         { key: { "metadata.workOrder.site": 1 } }
       ]);
     } catch (error) {
-      throw new import_node_server_utils25.InternalServerError(
+      throw new import_node_server_utils17.InternalServerError(
         "Failed to create index on hygiene unit checklist."
       );
     }
@@ -4131,7 +2800,7 @@ function useUnitChecklistRepo() {
     try {
       await collection.createIndex({ name: "text" });
     } catch (error) {
-      throw new import_node_server_utils25.InternalServerError(
+      throw new import_node_server_utils17.InternalServerError(
         "Failed to create text index on hygiene unit checklist."
       );
     }
@@ -4141,9 +2810,9 @@ function useUnitChecklistRepo() {
       value = MUnitChecklist(value);
       const res = await collection.insertOne(value, { session });
       delNamespace().then(() => {
-        import_node_server_utils25.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_utils25.logger.error(
+        import_node_server_utils17.logger.error(
           `Failed to clear cache for namespace: ${namespace_collection}`,
           err
         );
@@ -4169,31 +2838,31 @@ function useUnitChecklistRepo() {
       limit
     };
     try {
-      query.site = new import_mongodb14.ObjectId(site);
+      query.site = new import_mongodb10.ObjectId(site);
       cacheOptions.site = site.toString();
     } catch (error) {
-      throw new import_node_server_utils25.BadRequestError("Invalid site ID format.");
+      throw new import_node_server_utils17.BadRequestError("Invalid site ID format.");
     }
     try {
-      query.parentChecklist = new import_mongodb14.ObjectId(parentChecklist);
+      query.parentChecklist = new import_mongodb10.ObjectId(parentChecklist);
       cacheOptions.parentChecklist = parentChecklist.toString();
     } catch (error) {
-      throw new import_node_server_utils25.BadRequestError("Invalid parent checklist ID format.");
+      throw new import_node_server_utils17.BadRequestError("Invalid parent checklist ID format.");
     }
     try {
-      query.areaChecklist = new import_mongodb14.ObjectId(areaChecklist);
+      query.areaChecklist = new import_mongodb10.ObjectId(areaChecklist);
       cacheOptions.areaChecklist = areaChecklist.toString();
     } catch (error) {
-      throw new import_node_server_utils25.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_utils25.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_utils25.logger.info(`Cache hit for key: ${cacheKey}`);
+      import_node_server_utils17.logger.info(`Cache hit for key: ${cacheKey}`);
       return cachedData;
     }
     try {
@@ -4306,15 +2975,15 @@ function useUnitChecklistRepo() {
       ];
       const items = await collection.aggregate(pipeline).toArray();
       const length = await collection.countDocuments(query);
-      const paginatedData = (0, import_node_server_utils25.paginate)(items, page, limit, length);
+      const paginatedData = (0, import_node_server_utils17.paginate)(items, page, limit, length);
       const data = {
         attachments: areaAttachments,
         ...paginatedData
       };
       setCache(cacheKey, data, 15 * 60).then(() => {
-        import_node_server_utils25.logger.info(`Cache set for key: ${cacheKey}`);
+        import_node_server_utils17.logger.info(`Cache set for key: ${cacheKey}`);
       }).catch((err) => {
-        import_node_server_utils25.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) {
@@ -4323,9 +2992,9 @@ function useUnitChecklistRepo() {
   }
   async function getUnitChecklistById(_id) {
     try {
-      _id = new import_mongodb14.ObjectId(_id);
+      _id = new import_mongodb10.ObjectId(_id);
     } catch (error) {
-      throw new import_node_server_utils25.BadRequestError("Invalid unit checklist ID format.");
+      throw new import_node_server_utils17.BadRequestError("Invalid unit checklist ID format.");
     }
     try {
       return await collection.findOne({ _id });
@@ -4335,52 +3004,52 @@ function useUnitChecklistRepo() {
   }
   async function updateUnitChecklist(_id, value, session) {
     try {
-      _id = new import_mongodb14.ObjectId(_id);
+      _id = new import_mongodb10.ObjectId(_id);
     } catch (error) {
-      throw new import_node_server_utils25.BadRequestError("Invalid unit checklist ID format.");
+      throw new import_node_server_utils17.BadRequestError("Invalid unit checklist ID format.");
     }
     if (value.checkedBy && typeof value.checkedBy === "string") {
       try {
-        value.checkedBy = new import_mongodb14.ObjectId(value.checkedBy);
+        value.checkedBy = new import_mongodb10.ObjectId(value.checkedBy);
       } catch (error) {
-        throw new import_node_server_utils25.BadRequestError("Invalid checkedBy ID format.");
+        throw new import_node_server_utils17.BadRequestError("Invalid checkedBy ID format.");
       }
     }
     if ("metadata" in value && value.metadata?.workOrder) {
       const workOrder = value.metadata.workOrder;
       if (workOrder.category && typeof workOrder.category === "string") {
         try {
-          workOrder.category = new import_mongodb14.ObjectId(workOrder.category);
+          workOrder.category = new import_mongodb10.ObjectId(workOrder.category);
         } catch (error) {
-          throw new import_node_server_utils25.BadRequestError("Invalid category ID format.");
+          throw new import_node_server_utils17.BadRequestError("Invalid category ID format.");
         }
       }
       if (workOrder.createdBy && typeof workOrder.createdBy === "string") {
         try {
-          workOrder.createdBy = new import_mongodb14.ObjectId(workOrder.createdBy);
+          workOrder.createdBy = new import_mongodb10.ObjectId(workOrder.createdBy);
         } catch (error) {
-          throw new import_node_server_utils25.BadRequestError("Invalid createdBy ID format.");
+          throw new import_node_server_utils17.BadRequestError("Invalid createdBy ID format.");
         }
       }
       if (workOrder.serviceProvider && typeof workOrder.serviceProvider === "string") {
         try {
-          workOrder.serviceProvider = new import_mongodb14.ObjectId(workOrder.serviceProvider);
+          workOrder.serviceProvider = new import_mongodb10.ObjectId(workOrder.serviceProvider);
         } catch (error) {
-          throw new import_node_server_utils25.BadRequestError("Invalid serviceProvider ID format.");
+          throw new import_node_server_utils17.BadRequestError("Invalid serviceProvider ID format.");
         }
       }
       if (workOrder.organization && typeof workOrder.organization === "string") {
         try {
-          workOrder.organization = new import_mongodb14.ObjectId(workOrder.organization);
+          workOrder.organization = new import_mongodb10.ObjectId(workOrder.organization);
         } catch (error) {
-          throw new import_node_server_utils25.BadRequestError("Invalid organization ID format.");
+          throw new import_node_server_utils17.BadRequestError("Invalid organization ID format.");
         }
       }
       if (workOrder.site && typeof workOrder.site === "string") {
         try {
-          workOrder.site = new import_mongodb14.ObjectId(workOrder.site);
+          workOrder.site = new import_mongodb10.ObjectId(workOrder.site);
         } catch (error) {
-          throw new import_node_server_utils25.BadRequestError("Invalid site ID format.");
+          throw new import_node_server_utils17.BadRequestError("Invalid site ID format.");
         }
       }
     }
@@ -4392,12 +3061,12 @@ function useUnitChecklistRepo() {
         { session }
       );
       if (res.modifiedCount === 0) {
-        throw new import_node_server_utils25.InternalServerError("Unable to update unit checklist.");
+        throw new import_node_server_utils17.InternalServerError("Unable to update unit checklist.");
       }
       delNamespace().then(() => {
-        import_node_server_utils25.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_utils25.logger.error(
+        import_node_server_utils17.logger.error(
           `Failed to clear cache for namespace: ${namespace_collection}`,
           err
         );
@@ -4418,11 +3087,11 @@ function useUnitChecklistRepo() {
 }
 
 // src/controllers/hygiene-unit-checklist.controller.ts
-var import_node_server_utils27 = require("@iservice365/node-server-utils");
-var import_joi14 = __toESM(require("joi"));
+var import_node_server_utils19 = require("@iservice365/node-server-utils");
+var import_joi10 = __toESM(require("joi"));
 
 // src/services/hygiene-unit-checklist.service.ts
-var import_node_server_utils26 = require("@iservice365/node-server-utils");
+var import_node_server_utils18 = require("@iservice365/node-server-utils");
 var import_core = require("@iservice365/core");
 function useUnitChecklistService() {
   const {
@@ -4438,7 +3107,7 @@ function useUnitChecklistService() {
       const result = await _updateUnitChecklist(id, value);
       return result;
     } catch (error) {
-      import_node_server_utils26.logger.error(`Error updating unit checklist with id ${id}:`, error);
+      import_node_server_utils18.logger.error(`Error updating unit checklist with id ${id}:`, error);
       throw error;
     }
   }
@@ -4449,12 +3118,12 @@ function useUnitChecklistService() {
       if (value.metadata?.workOrder) {
         const existingChecklist = await _getUnitChecklistById(id);
         if (!existingChecklist)
-          throw new import_node_server_utils26.NotFoundError("Unit checklist not found.");
+          throw new import_node_server_utils18.NotFoundError("Unit checklist not found.");
         const site = await getSiteById(
           existingChecklist.site
         );
         if (!site)
-          throw new import_node_server_utils26.NotFoundError("Site not found.");
+          throw new import_node_server_utils18.NotFoundError("Site not found.");
         const workOrderData = {
           ...value.metadata.workOrder,
           attachments: value.metadata.attachments,
@@ -4467,12 +3136,12 @@ function useUnitChecklistService() {
           fullHost
         );
         if (!workOrder)
-          throw new import_node_server_utils26.NotFoundError("Failed to create work order.");
+          throw new import_node_server_utils18.NotFoundError("Failed to create work order.");
       }
       const result = await _updateUnitChecklist(id, value);
       return result;
     } catch (error) {
-      import_node_server_utils26.logger.error(`Error updating unit checklist with id ${id}:`, error);
+      import_node_server_utils18.logger.error(`Error updating unit checklist with id ${id}:`, error);
       throw error;
     }
   }
@@ -4502,8 +3171,8 @@ function useUnitChecklistController() {
     const payload = { ...req.body, ...req.params, createdBy };
     const { error } = unitChecklistSchema.validate(payload);
     if (error) {
-      import_node_server_utils27.logger.log({ level: "error", message: error.message });
-      next(new import_node_server_utils27.BadRequestError(error.message));
+      import_node_server_utils19.logger.log({ level: "error", message: error.message });
+      next(new import_node_server_utils19.BadRequestError(error.message));
       return;
     }
     try {
@@ -4511,26 +3180,26 @@ function useUnitChecklistController() {
       res.status(201).json({ message: "Unit checklist created successfully.", id });
       return;
     } catch (error2) {
-      import_node_server_utils27.logger.log({ level: "error", message: error2.message });
+      import_node_server_utils19.logger.log({ level: "error", message: error2.message });
       next(error2);
       return;
     }
   }
   async function getAllUnitChecklist(req, res, next) {
     const query = { ...req.query, ...req.params };
-    const validation = import_joi14.default.object({
-      page: import_joi14.default.number().min(1).optional().allow("", null),
-      limit: import_joi14.default.number().min(1).optional().allow("", null),
-      search: import_joi14.default.string().optional().allow("", null),
-      site: import_joi14.default.string().hex().required(),
-      type: import_joi14.default.string().valid(...allowedTypes).required(),
-      parentChecklist: import_joi14.default.string().hex().required(),
-      areaChecklist: import_joi14.default.string().hex().required()
+    const validation = import_joi10.default.object({
+      page: import_joi10.default.number().min(1).optional().allow("", null),
+      limit: import_joi10.default.number().min(1).optional().allow("", null),
+      search: import_joi10.default.string().optional().allow("", null),
+      site: import_joi10.default.string().hex().required(),
+      type: import_joi10.default.string().valid(...allowedTypes).required(),
+      parentChecklist: import_joi10.default.string().hex().required(),
+      areaChecklist: import_joi10.default.string().hex().required()
     });
     const { error } = validation.validate(query);
     if (error) {
-      import_node_server_utils27.logger.log({ level: "error", message: error.message });
-      next(new import_node_server_utils27.BadRequestError(error.message));
+      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;
@@ -4553,7 +3222,7 @@ function useUnitChecklistController() {
       res.json(data);
       return;
     } catch (error2) {
-      import_node_server_utils27.logger.log({ level: "error", message: error2.message });
+      import_node_server_utils19.logger.log({ level: "error", message: error2.message });
       next(error2);
       return;
     }
@@ -4565,14 +3234,14 @@ function useUnitChecklistController() {
     ) : {};
     const checkedBy = cookies["user"] || "";
     const payload = { id: req.params.id, checkedBy };
-    const validation = import_joi14.default.object({
-      id: import_joi14.default.string().hex().required(),
-      checkedBy: import_joi14.default.string().hex().required()
+    const validation = import_joi10.default.object({
+      id: import_joi10.default.string().hex().required(),
+      checkedBy: import_joi10.default.string().hex().required()
     });
     const { error } = validation.validate(payload);
     if (error) {
-      import_node_server_utils27.logger.log({ level: "error", message: error.message });
-      next(new import_node_server_utils27.BadRequestError(error.message));
+      import_node_server_utils19.logger.log({ level: "error", message: error.message });
+      next(new import_node_server_utils19.BadRequestError(error.message));
       return;
     }
     try {
@@ -4581,7 +3250,7 @@ function useUnitChecklistController() {
       res.json({ message: "Unit checklist approved successfully." });
       return;
     } catch (error2) {
-      import_node_server_utils27.logger.log({ level: "error", message: error2.message });
+      import_node_server_utils19.logger.log({ level: "error", message: error2.message });
       next(error2);
       return;
     }
@@ -4596,17 +3265,17 @@ function useUnitChecklistController() {
       req.body.workOrder.createdBy = checkedBy;
     }
     const payload = { id: req.params.id, checkedBy, ...req.body };
-    const validation = import_joi14.default.object({
-      id: import_joi14.default.string().hex().required(),
-      attachments: import_joi14.default.array().items(import_joi14.default.string()).optional(),
-      remarks: import_joi14.default.string().required(),
+    const validation = import_joi10.default.object({
+      id: import_joi10.default.string().hex().required(),
+      attachments: import_joi10.default.array().items(import_joi10.default.string()).optional(),
+      remarks: import_joi10.default.string().required(),
       workOrder: import_core2.workOrderSchema.optional(),
-      checkedBy: import_joi14.default.string().hex().required()
+      checkedBy: import_joi10.default.string().hex().required()
     });
     const { error } = validation.validate(payload);
     if (error) {
-      import_node_server_utils27.logger.log({ level: "error", message: error.message });
-      next(new import_node_server_utils27.BadRequestError(error.message));
+      import_node_server_utils19.logger.log({ level: "error", message: error.message });
+      next(new import_node_server_utils19.BadRequestError(error.message));
       return;
     }
     try {
@@ -4630,7 +3299,7 @@ function useUnitChecklistController() {
       res.json({ message: "Unit checklist rejected successfully." });
       return;
     } catch (error2) {
-      import_node_server_utils27.logger.log({ level: "error", message: error2.message });
+      import_node_server_utils19.logger.log({ level: "error", message: error2.message });
       next(error2);
       return;
     }
@@ -4647,32 +3316,21 @@ function useUnitChecklistController() {
   MArea,
   MAreaChecklist,
   MParentChecklist,
-  MScheduleTaskArea,
-  MToiletLocation,
   MUnit,
   MUnitChecklist,
-  allowedStatus,
-  allowedTypes,
+  allowedChecklistStatus,
   areaChecklistSchema,
   areaSchema,
   parentChecklistSchema,
-  scheduleTaskAreaSchema,
-  toiletLocationSchema,
   unitChecklistSchema,
   unitSchema,
   useAreaChecklistController,
   useAreaChecklistRepo,
   useAreaController,
-  useAreaRepository,
+  useAreaRepo,
   useAreaService,
   useParentChecklistController,
   useParentChecklistRepo,
-  useScheduleTaskAreaController,
-  useScheduleTaskAreaRepository,
-  useScheduleTaskAreaService,
-  useToiletLocationController,
-  useToiletLocationRepository,
-  useToiletLocationService,
   useUnitChecklistController,
   useUnitChecklistRepo,
   useUnitController,