@iservice365/module-hygiene 0.2.0 → 1.0.0

package/dist/index.js

@@ -33,39 +33,40 @@ __export(src_exports, {
   MArea: () => MArea,
   MAreaChecklist: () => MAreaChecklist,
   MParentChecklist: () => MParentChecklist,
+  MSupply: () => MSupply,
   MUnit: () => MUnit,
-  MUnitChecklist: () => MUnitChecklist,
   allowedChecklistStatus: () => allowedChecklistStatus,
+  allowedStatus: () => allowedStatus,
+  allowedTypes: () => allowedTypes,
   areaChecklistSchema: () => areaChecklistSchema,
   areaSchema: () => areaSchema,
   parentChecklistSchema: () => parentChecklistSchema,
-  unitChecklistSchema: () => unitChecklistSchema,
+  supplySchema: () => supplySchema,
   unitSchema: () => unitSchema,
   useAreaChecklistController: () => useAreaChecklistController,
   useAreaChecklistRepo: () => useAreaChecklistRepo,
+  useAreaChecklistService: () => useAreaChecklistService,
   useAreaController: () => useAreaController,
   useAreaRepo: () => useAreaRepo,
   useAreaService: () => useAreaService,
   useParentChecklistController: () => useParentChecklistController,
   useParentChecklistRepo: () => useParentChecklistRepo,
-  useUnitChecklistController: () => useUnitChecklistController,
-  useUnitChecklistRepo: () => useUnitChecklistRepo,
+  useSupplyController: () => useSupplyController,
+  useSupplyRepository: () => useSupplyRepository,
   useUnitController: () => useUnitController,
   useUnitRepository: () => useUnitRepository,
   useUnitService: () => useUnitService
 });
 module.exports = __toCommonJS(src_exports);
 
-// src/models/hygiene-area.model.ts
-var import_node_server_utils = require("@iservice365/node-server-utils");
-var import_joi = __toESM(require("joi"));
-var import_mongodb = require("mongodb");
-
 // src/models/hygiene-base.model.ts
 var allowedTypes = ["common", "toilet"];
 var allowedStatus = ["ready", "ongoing", "completed"];
 
 // src/models/hygiene-area.model.ts
+var import_node_server_utils = require("@iservice365/node-server-utils");
+var import_joi = __toESM(require("joi"));
+var import_mongodb = require("mongodb");
 var areaSchema = import_joi.default.object({
   site: import_joi.default.string().hex().required(),
   name: import_joi.default.string().required(),
@@ -315,6 +316,7 @@ function useAreaRepo() {
         { $match: query },
         {
           $project: {
+            type: 1,
             name: 1,
             set: 1,
             units: 1
@@ -334,7 +336,38 @@ function useAreaRepo() {
       throw error;
     }
   }
-  async function updateArea(_id, value) {
+  async function verifyAreaByUnitId(unitId) {
+    try {
+      unitId = new import_mongodb2.ObjectId(unitId);
+    } catch (error) {
+      throw new import_node_server_utils2.BadRequestError("Invalid unit ID format.");
+    }
+    const query = {
+      "units.unit": unitId,
+      status: { $ne: "deleted" }
+    };
+    const cacheKey = (0, import_node_server_utils2.makeCacheKey)(namespace_collection, {
+      verify_unitId: unitId.toString()
+    });
+    const cachedData = await getCache(cacheKey);
+    if (cachedData) {
+      import_node_server_utils2.logger.info(`Cache hit for key: ${cacheKey}`);
+      return cachedData;
+    }
+    try {
+      const count = await collection.countDocuments(query);
+      const result = count > 0;
+      setCache(cacheKey, result, 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 result;
+    } catch (error) {
+      throw error;
+    }
+  }
+  async function updateArea(_id, value, session) {
     try {
       _id = new import_mongodb2.ObjectId(_id);
     } catch (error) {
@@ -365,7 +398,11 @@ function useAreaRepo() {
           }
         });
       }
-      const res = await collection.updateOne({ _id }, { $set: updateValue });
+      const res = await collection.updateOne(
+        { _id },
+        { $set: updateValue },
+        { session }
+      );
       if (res.modifiedCount === 0) {
         throw new import_node_server_utils2.InternalServerError("Unable to update cleaning area.");
       }
@@ -386,29 +423,25 @@ function useAreaRepo() {
       throw error;
     }
   }
-  async function updateAreaChecklist(_id, value) {
+  async function updateAreaChecklist(unitId, name, session) {
     try {
-      _id = new import_mongodb2.ObjectId(_id);
+      unitId = new import_mongodb2.ObjectId(unitId);
     } catch (error) {
-      throw new import_node_server_utils2.BadRequestError("Invalid area ID format.");
-    }
-    if (value.units && Array.isArray(value.units)) {
-      value.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}`);
-        }
-      });
+      throw new import_node_server_utils2.BadRequestError("Invalid unit ID format.");
     }
     try {
-      const updateValue = { ...value, updatedAt: /* @__PURE__ */ new Date() };
-      const res = await collection.updateOne({ _id }, { $set: updateValue });
+      const res = await collection.updateMany(
+        { "units.unit": unitId },
+        {
+          $set: {
+            "units.$.name": name,
+            updatedAt: /* @__PURE__ */ new Date()
+          }
+        },
+        { session }
+      );
       if (res.modifiedCount === 0) {
-        throw new import_node_server_utils2.InternalServerError("Unable to update cleaning area.");
+        throw new import_node_server_utils2.InternalServerError("Unable to update unit name in areas.");
       }
       delNamespace().then(() => {
         import_node_server_utils2.logger.info(`Cache cleared for namespace: ${namespace_collection}`);
@@ -464,6 +497,7 @@ function useAreaRepo() {
     getAreas,
     getAreasForChecklist,
     getAreaById,
+    verifyAreaByUnitId,
     updateArea,
     updateAreaChecklist,
     deleteArea
@@ -499,7 +533,7 @@ function useAreaService() {
           skippedRows.push(i + 1);
           continue;
         }
-        const areaType = String(row.TYPE).trim();
+        const areaType = String(row.TYPE).trim().toLowerCase();
         if (!areaType) {
           import_node_server_utils3.logger.warn(`Skipping row ${i + 1} with empty area type`);
           skippedRows.push(i + 1);
@@ -547,18 +581,22 @@ function useAreaService() {
       }
       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(", ")}`
-          );
+        if (duplicateAreas.length > 0 && failedAreas.length === 0 && skippedRows.length === 0) {
+          return {
+            message: `No new areas were created. All ${duplicateAreas.length} areas already exist in the system: ${duplicateAreas.join(", ")}`
+          };
         } else if (failedAreas.length > 0) {
           throw new import_node_server_utils3.BadRequestError(
-            `No areas were created. Please check your data format and ensure area names are valid.`
+            `No areas were created. ${failedAreas.length} areas failed due to errors. Please check your data format and ensure area names are valid.`
           );
-        } else if (skippedRows.length > 0) {
+        } else if (skippedRows.length > 0 && duplicateAreas.length === 0) {
           throw new import_node_server_utils3.BadRequestError(
-            `No areas were created. All rows contained invalid or missing area names.`
+            `No areas were created. All ${skippedRows.length} rows contained invalid or missing data.`
           );
+        } else {
+          return {
+            message: `No new areas were created. ${duplicateAreas.length} areas already exist, ${skippedRows.length} rows had invalid data.`
+          };
         }
       }
       return { message };
@@ -566,10 +604,6 @@ function useAreaService() {
       import_node_server_utils3.logger.error("Error while uploading area information", error);
       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."
@@ -622,7 +656,6 @@ function useAreaController() {
     getAreas: _getAreas,
     getAreaById: _getAreaById,
     updateArea: _updateArea,
-    updateAreaChecklist: _updateAreaChecklist,
     deleteArea: _deleteById
   } = useAreaRepo();
   const { importArea: _importArea } = useAreaService();
@@ -728,36 +761,6 @@ function useAreaController() {
       return;
     }
   }
-  async function updateAreaChecklist(req, res, next) {
-    const payload = { id: req.params.id, ...req.body };
-    const schema = import_joi2.default.object({
-      id: import_joi2.default.string().hex().required(),
-      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 }).messages({
-        "array.unique": "Duplicate area units are not allowed"
-      })
-    });
-    const { error } = schema.validate(payload);
-    if (error) {
-      import_node_server_utils4.logger.log({ level: "error", message: error.message });
-      next(new import_node_server_utils4.BadRequestError(error.message));
-      return;
-    }
-    try {
-      const { id, ...value } = payload;
-      await _updateAreaChecklist(id, value);
-      res.json({ message: "Area updated successfully." });
-      return;
-    } catch (error2) {
-      import_node_server_utils4.logger.log({ level: "error", message: error2.message });
-      next(error2);
-      return;
-    }
-  }
   async function deleteArea(req, res, next) {
     const id = req.params.id;
     const validation = import_joi2.default.string().hex().required();
@@ -806,7 +809,6 @@ function useAreaController() {
     getAreas,
     getAreaById,
     updateArea,
-    updateAreaChecklist,
     deleteArea,
     importArea
   };
@@ -960,7 +962,7 @@ function useUnitRepository() {
       throw error;
     }
   }
-  async function updateUnit(_id, value) {
+  async function updateUnit(_id, value, session) {
     try {
       _id = new import_mongodb4.ObjectId(_id);
     } catch (error) {
@@ -968,7 +970,11 @@ function useUnitRepository() {
     }
     try {
       const updateValue = { ...value, updatedAt: /* @__PURE__ */ new Date() };
-      const res = await collection.updateOne({ _id }, { $set: updateValue });
+      const res = await collection.updateOne(
+        { _id },
+        { $set: updateValue },
+        { session }
+      );
       if (res.modifiedCount === 0) {
         throw new import_node_server_utils6.InternalServerError("Unable to update cleaning unit.");
       }
@@ -1035,7 +1041,12 @@ function useUnitRepository() {
 
 // src/services/hygiene-unit.service.ts
 function useUnitService() {
-  const { createUnit: _createUnit } = useUnitRepository();
+  const {
+    createUnit: _createUnit,
+    updateUnit: _updateUnit,
+    deleteUnit: _deleteUnit
+  } = useUnitRepository();
+  const { verifyAreaByUnitId, updateAreaChecklist } = useAreaRepo();
   async function importUnit({
     dataJson,
     site
@@ -1129,20 +1140,61 @@ function useUnitService() {
       }
     }
   }
-  return { importUnit };
+  async function updateUnit(_id, value) {
+    const session = import_node_server_utils7.useAtlas.getClient()?.startSession();
+    try {
+      session?.startTransaction();
+      const result = await _updateUnit(_id, value, session);
+      const isExistingArea = await verifyAreaByUnitId(_id);
+      if (isExistingArea) {
+        await updateAreaChecklist(_id, value.name, session);
+      }
+      await session?.commitTransaction();
+      return result;
+    } catch (error) {
+      import_node_server_utils7.logger.error(`Error updating unit and associated areas:`, error);
+      if (session?.inTransaction()) {
+        await session?.abortTransaction();
+      }
+      throw error;
+    } finally {
+      session?.endSession();
+    }
+  }
+  async function deleteUnit(_id) {
+    const session = import_node_server_utils7.useAtlas.getClient()?.startSession();
+    try {
+      session?.startTransaction();
+      const isExistingArea = await verifyAreaByUnitId(_id);
+      if (isExistingArea) {
+        throw new import_node_server_utils7.BadRequestError("Failed to delete unit, unit is in use.");
+      }
+      const result = await _deleteUnit(_id, session);
+      await session?.commitTransaction();
+      return result;
+    } catch (error) {
+      import_node_server_utils7.logger.error(`Error deleting unit:`, error);
+      if (session?.inTransaction()) {
+        await session?.abortTransaction();
+      }
+      throw error;
+    } finally {
+      session?.endSession();
+    }
+  }
+  return { importUnit, updateUnit, deleteUnit };
 }
 
 // src/controllers/hygiene-unit.controller.ts
 var import_node_server_utils8 = require("@iservice365/node-server-utils");
 var import_joi4 = __toESM(require("joi"));
 function useUnitController() {
+  const { createUnit: _createUnit, getUnits: _getUnits } = useUnitRepository();
   const {
-    createUnit: _createUnit,
-    getUnits: _getUnits,
     updateUnit: _updateUnit,
-    deleteUnit: _deleteUnit
-  } = useUnitRepository();
-  const { importUnit: _importUnit } = useUnitService();
+    deleteUnit: _deleteUnit,
+    importUnit: _importUnit
+  } = useUnitService();
   async function createUnit(req, res, next) {
     const payload = { ...req.body, ...req.params };
     const { error } = unitSchema.validate(payload);
@@ -1467,164 +1519,37 @@ function useParentChecklistRepo() {
       throw error;
     }
   }
-  async function updateParentChecklistStatuses(createdAt) {
+  async function updateParentChecklistStatuses(_id, status, session) {
     try {
-      const currentDate = /* @__PURE__ */ new Date();
-      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);
-      endOfDay.setUTCHours(23, 59, 59, 999);
-      import_node_server_utils10.logger.info(
-        `Updating parent checklist statuses for date: ${dateToUpdate.toISOString().split("T")[0]}`
-      );
-      const statusUpdates = await collection.aggregate([
-        {
-          $match: {
-            createdAt: {
-              $gte: startOfDay,
-              $lte: endOfDay
-            }
-          }
-        },
-        {
-          $lookup: {
-            from: "site.cleaning.schedule.areas",
-            let: { parentId: "$_id" },
-            pipeline: [
-              {
-                $match: {
-                  $expr: { $eq: ["$parentChecklist", "$$parentId"] }
-                }
-              },
-              {
-                $group: {
-                  _id: {
-                    parentChecklist: "$parentChecklist"
-                  },
-                  completedCount: {
-                    $sum: {
-                      $cond: [{ $eq: ["$status", "completed"] }, 1, 0]
-                    }
-                  },
-                  ongoingCount: {
-                    $sum: {
-                      $cond: [{ $eq: ["$status", "ongoing"] }, 1, 0]
-                    }
-                  },
-                  readyCount: {
-                    $sum: {
-                      $cond: [{ $eq: ["$status", "ready"] }, 1, 0]
-                    }
-                  },
-                  totalCount: { $sum: 1 }
-                }
-              },
-              {
-                $addFields: {
-                  finalStatus: {
-                    $cond: {
-                      if: {
-                        $and: [
-                          { $gt: ["$completedCount", 0] },
-                          { $eq: ["$ongoingCount", 0] },
-                          { $eq: ["$readyCount", 0] }
-                        ]
-                      },
-                      then: "completed",
-                      else: {
-                        $cond: {
-                          if: {
-                            $and: [
-                              { $eq: ["$completedCount", 0] },
-                              { $eq: ["$ongoingCount", 0] }
-                            ]
-                          },
-                          then: "expired",
-                          else: "ongoing"
-                        }
-                      }
-                    }
-                  },
-                  completedAt: {
-                    $cond: {
-                      if: {
-                        $and: [
-                          { $gt: ["$completedCount", 0] },
-                          { $eq: ["$ongoingCount", 0] },
-                          { $eq: ["$readyCount", 0] }
-                        ]
-                      },
-                      then: /* @__PURE__ */ new Date(),
-                      else: null
-                    }
-                  }
-                }
-              }
-            ],
-            as: "areaStats"
-          }
-        },
-        {
-          $match: {
-            "areaStats.0": { $exists: true }
-          }
-        },
-        {
-          $addFields: {
-            areaData: { $arrayElemAt: ["$areaStats", 0] }
-          }
-        },
-        {
-          $project: {
-            _id: 1,
-            newStatus: "$areaData.finalStatus",
-            completedAt: "$areaData.completedAt"
-          }
-        }
-      ]).toArray();
-      import_node_server_utils10.logger.info(
-        `Found ${statusUpdates.length} parent checklists to potentially update`
+      _id = new import_mongodb6.ObjectId(_id);
+    } catch (error) {
+      throw new import_node_server_utils10.BadRequestError("Invalid parent checklist ID format.");
+    }
+    try {
+      const updateValue = {
+        status,
+        updatedAt: /* @__PURE__ */ new Date()
+      };
+      const res = await collection.updateOne(
+        { _id },
+        { $set: updateValue },
+        { session }
       );
-      if (statusUpdates.length === 0) {
-        import_node_server_utils10.logger.info(
-          `No parent checklists found for date range: ${startOfDay.toISOString()} to ${endOfDay.toISOString()}`
+      if (res.modifiedCount === 0) {
+        throw new import_node_server_utils10.InternalServerError(
+          "Unable to update parent checklist status."
         );
-        return null;
       }
-      const bulkOps = statusUpdates.map((update) => {
-        import_node_server_utils10.logger.info(
-          `Updating parent checklist ${update._id} with status: ${update.newStatus}`
+      delNamespace().then(() => {
+        import_node_server_utils10.logger.info(`Cache cleared for namespace: ${namespace_collection}`);
+      }).catch((err) => {
+        import_node_server_utils10.logger.error(
+          `Failed to clear cache for namespace: ${namespace_collection}`,
+          err
         );
-        return {
-          updateOne: {
-            filter: { _id: update._id },
-            update: {
-              $set: {
-                status: update.newStatus,
-                completedAt: update.completedAt,
-                updatedAt: /* @__PURE__ */ new Date()
-              }
-            }
-          }
-        };
       });
-      let result = null;
-      if (bulkOps.length > 0) {
-        result = await collection.bulkWrite(bulkOps);
-        delNamespace().then(() => {
-          import_node_server_utils10.logger.info(`Cache cleared for namespace: ${namespace_collection}`);
-        }).catch((err) => {
-          import_node_server_utils10.logger.error(
-            `Failed to clear cache for namespace: ${namespace_collection}`,
-            err
-          );
-        });
-      }
-      import_node_server_utils10.logger.info(`Updated statuses for ${bulkOps.length} parent checklists.`);
-      return result;
+      return res.modifiedCount;
     } catch (error) {
-      import_node_server_utils10.logger.error("Failed to update parent checklist statuses", error);
       throw error;
     }
   }
@@ -1751,6 +1676,7 @@ var areaChecklistSchema = import_joi7.default.object({
       set: import_joi7.default.number().min(0).required(),
       units: import_joi7.default.array().items(
         import_joi7.default.object({
+          unit: import_joi7.default.string().hex().required(),
           name: import_joi7.default.string().required()
         }).required()
       ).min(1).required()
@@ -1775,9 +1701,11 @@ function MAreaChecklist(value) {
       return {
         set: checklistItem.set,
         units: checklistItem.units.map((unit) => ({
+          unit: new import_mongodb7.ObjectId(unit.unit),
           name: unit.name,
           status: "ready",
           remarks: "",
+          completedBy: "",
           timestamp: ""
         }))
       };
@@ -1790,10 +1718,14 @@ function MAreaChecklist(value) {
     checklist: value.checklist || [],
     status: "ready",
     createdAt: /* @__PURE__ */ new Date(),
+    completedAt: "",
     updatedAt: ""
   };
 }
 
+// src/services/hygiene-area-checklist.service.ts
+var import_node_server_utils14 = require("@iservice365/node-server-utils");
+
 // src/repositories/hygiene-area-checklist.repository.ts
 var import_node_server_utils13 = require("@iservice365/node-server-utils");
 var import_mongodb8 = require("mongodb");
@@ -1803,13 +1735,8 @@ function useAreaChecklistRepo() {
     throw new import_node_server_utils13.InternalServerError("Unable to connect to server.");
   }
   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_utils13.useCache)(namespace_collection);
-  const { delNamespace: delUnitNamespace } = (0, import_node_server_utils13.useCache)(
-    unit_checklist_collection
-  );
   async function createIndex() {
     try {
       await collection.createIndexes([
@@ -1817,7 +1744,8 @@ function useAreaChecklistRepo() {
         { key: { type: 1 } },
         { key: { status: 1 } },
         { key: { createdAt: 1 } },
-        { key: { acceptedBy: 1 } }
+        { key: { "checklist.units.unit": 1 } },
+        { key: { "checklist.units.status": 1 } }
       ]);
     } catch (error) {
       throw new import_node_server_utils13.InternalServerError(
@@ -1827,7 +1755,11 @@ function useAreaChecklistRepo() {
   }
   async function createTextIndex() {
     try {
-      await collection.createIndex({ name: "text" });
+      await collection.createIndex({
+        name: "text",
+        "checklist.units.name": "text",
+        "checklist.units.remarks": "text"
+      });
     } catch (error) {
       throw new import_node_server_utils13.InternalServerError(
         "Failed to create text index on hygiene checklist area."
@@ -1878,7 +1810,7 @@ function useAreaChecklistRepo() {
     search = "",
     type,
     schedule
-  }) {
+  }, session) {
     page = page > 0 ? page - 1 : 0;
     const query = {};
     const cacheOptions = {
@@ -1900,10 +1832,12 @@ function useAreaChecklistRepo() {
       cacheOptions.search = search;
     }
     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;
+    if (!session) {
+      const cachedData = await getCache(cacheKey);
+      if (cachedData) {
+        import_node_server_utils13.logger.info(`Cache hit for key: ${cacheKey}`);
+        return cachedData;
+      }
     }
     try {
       const pipeline = [
@@ -1928,7 +1862,15 @@ function useAreaChecklistRepo() {
             set: {
               $cond: {
                 if: { $gt: [{ $size: { $ifNull: ["$checklist", []] } }, 0] },
-                then: { $max: "$checklist.set" },
+                then: {
+                  $max: {
+                    $map: {
+                      input: "$checklist",
+                      as: "item",
+                      in: { $toInt: "$$item.set" }
+                    }
+                  }
+                },
                 else: 0
               }
             }
@@ -1938,8 +1880,8 @@ function useAreaChecklistRepo() {
         { $skip: page * limit },
         { $limit: limit }
       ];
-      const items = await collection.aggregate(pipeline).toArray();
-      const length = await collection.countDocuments(query);
+      const items = await collection.aggregate(pipeline, { session }).toArray();
+      const length = await collection.countDocuments(query, { session });
       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}`);
@@ -1955,31 +1897,27 @@ function useAreaChecklistRepo() {
     page = 1,
     limit = 10,
     search = "",
-    site,
     type,
     schedule,
     status,
-    createdAt,
-    user
+    createdAt
   }) {
     page = page > 0 ? page - 1 : 0;
-    const query = { type };
+    const query = {};
     const cacheOptions = {
       page,
       limit
     };
-    try {
-      query.site = new import_mongodb8.ObjectId(site);
-      cacheOptions.site = site.toString();
-    } catch (error) {
-      throw new import_node_server_utils13.BadRequestError("Invalid site ID format.");
-    }
     try {
       query.schedule = new import_mongodb8.ObjectId(schedule);
       cacheOptions.schedule = schedule.toString();
     } catch (error) {
       throw new import_node_server_utils13.BadRequestError("Invalid parent checklist ID format.");
     }
+    if (type) {
+      query.type = type;
+      cacheOptions.type = type;
+    }
     if (search) {
       query.$text = { $search: search };
       cacheOptions.search = search;
@@ -1997,14 +1935,6 @@ function useAreaChecklistRepo() {
     } else {
       query.status = { $in: ["ongoing", "completed"] };
     }
-    if (user) {
-      try {
-        query.acceptedBy = new import_mongodb8.ObjectId(user);
-        cacheOptions.user = user.toString();
-      } catch (error) {
-        throw new import_node_server_utils13.BadRequestError("Invalid user ID format.");
-      }
-    }
     const cacheKey = (0, import_node_server_utils13.makeCacheKey)(namespace_collection, cacheOptions);
     const cachedData = await getCache(cacheKey);
     if (cachedData) {
@@ -2014,29 +1944,12 @@ function useAreaChecklistRepo() {
     try {
       const pipeline = [
         { $match: query },
-        {
-          $lookup: {
-            from: "users",
-            localField: "acceptedBy",
-            foreignField: "_id",
-            pipeline: [
-              ...search ? [{ $match: { name: { $regex: search, $options: "i" } } }] : [],
-              { $project: { name: 1 } }
-            ],
-            as: "acceptedBy"
-          }
-        },
-        {
-          $unwind: {
-            path: "$acceptedBy",
-            preserveNullAndEmptyArrays: true
-          }
-        },
         {
           $project: {
             name: 1,
+            type: 1,
             createdAt: 1,
-            acceptedByName: "$acceptedBy.name",
+            completedAt: 1,
             status: {
               $switch: {
                 branches: [
@@ -2050,9 +1963,22 @@ function useAreaChecklistRepo() {
                 default: "$status"
               }
             },
-            startedAt: "$acceptedAt",
-            endedAt: "$completedAt"
-          }
+            set: {
+              $cond: {
+                if: { $gt: [{ $size: { $ifNull: ["$checklist", []] } }, 0] },
+                then: {
+                  $max: {
+                    $map: {
+                      input: "$checklist",
+                      as: "item",
+                      in: { $toInt: "$$item.set" }
+                    }
+                  }
+                },
+                else: 0
+              }
+            }
+          }
         },
         { $sort: { status: 1 } },
         { $skip: page * limit },
@@ -2089,75 +2015,120 @@ function useAreaChecklistRepo() {
       const areaPipeline = [
         { $match: { _id } },
         {
-          $lookup: {
-            from: "users",
-            localField: "createdBy",
-            foreignField: "_id",
-            pipeline: [{ $project: { name: 1 } }],
-            as: "createdBy"
+          $project: {
+            name: 1,
+            createdAt: 1,
+            completedAt: 1,
+            status: {
+              $switch: {
+                branches: [
+                  { case: { $eq: ["$status", "ready"] }, then: "Ready" },
+                  { case: { $eq: ["$status", "ongoing"] }, then: "Ongoing" },
+                  {
+                    case: { $eq: ["$status", "completed"] },
+                    then: "Completed"
+                  }
+                ],
+                default: "$status"
+              }
+            }
+          }
+        }
+      ];
+      const unitPipeline = [
+        { $match: { _id } },
+        {
+          $unwind: {
+            path: "$checklist",
+            preserveNullAndEmptyArrays: false
           }
         },
         {
           $unwind: {
-            path: "$createdBy",
-            preserveNullAndEmptyArrays: true
+            path: "$checklist.units",
+            preserveNullAndEmptyArrays: false
           }
         },
         {
           $lookup: {
             from: "users",
-            localField: "acceptedBy",
-            foreignField: "_id",
-            pipeline: [{ $project: { name: 1 } }],
-            as: "acceptedBy"
+            let: { completedById: "$checklist.units.completedBy" },
+            pipeline: [
+              {
+                $match: {
+                  $expr: {
+                    $and: [
+                      { $ne: ["$$completedById", ""] },
+                      { $eq: ["$_id", "$$completedById"] }
+                    ]
+                  }
+                }
+              },
+              { $project: { name: 1 } }
+            ],
+            as: "completedBy"
           }
         },
         {
           $unwind: {
-            path: "$acceptedBy",
+            path: "$completedBy",
             preserveNullAndEmptyArrays: true
           }
         },
         {
           $project: {
-            name: 1,
-            createdAt: 1,
-            createdByName: "$createdBy.name",
-            startedAt: "$acceptedAt",
-            endedAt: "$completedAt",
+            _id: 0,
+            set: "$checklist.set",
+            unit: "$checklist.units.unit",
+            name: "$checklist.units.name",
+            remarks: "$checklist.units.remarks",
             status: {
               $switch: {
                 branches: [
-                  { case: { $eq: ["$status", "ready"] }, then: "Ready" },
-                  { case: { $eq: ["$status", "ongoing"] }, then: "Ongoing" },
                   {
-                    case: { $eq: ["$status", "completed"] },
+                    case: { $eq: ["$checklist.units.status", "ready"] },
+                    then: "Ready"
+                  },
+                  {
+                    case: { $eq: ["$checklist.units.status", "completed"] },
                     then: "Completed"
                   }
                 ],
-                default: "$status"
+                default: "$checklist.units.status"
               }
             },
-            signature: 1,
-            acceptedByName: "$acceptedBy.name"
+            completedByName: "$completedBy.name",
+            timestamp: "$checklist.units.timestamp"
           }
-        }
-      ];
-      const unitPipeline = [
-        { $match: { areaChecklist: _id } },
+        },
+        { $sort: { set: 1, name: 1 } },
+        {
+          $group: {
+            _id: "$set",
+            units: {
+              $push: {
+                unit: "$unit",
+                name: "$name",
+                status: "$status",
+                remarks: "$remarks",
+                completedByName: "$completedByName",
+                timestamp: "$timestamp"
+              }
+            }
+          }
+        },
         {
           $project: {
-            name: 1,
-            remarks: "$metadata.remarks",
-            attachments: "$metadata.attachments",
-            approve: { $ifNull: ["$approve", null] },
-            reject: { $ifNull: ["$reject", null] }
+            _id: 0,
+            set: "$_id",
+            units: 1
           }
-        }
+        },
+        { $sort: { set: 1 } }
       ];
       const [area, units] = await Promise.all([
         collection.aggregate(areaPipeline).toArray(),
-        unitChecklistCollection.aggregate(unitPipeline).toArray()
+        collection.aggregate(unitPipeline).toArray()
       ]);
       if (!area.length) {
         throw new import_node_server_utils13.BadRequestError("Area checklist not found.");
@@ -2176,64 +2147,166 @@ function useAreaChecklistRepo() {
       throw error;
     }
   }
-  async function acceptAreaChecklist(_id, acceptedBy) {
+  async function getAreaChecklistUnits({
+    page = 1,
+    limit = 10,
+    search = "",
+    _id
+  }, session) {
+    page = page > 0 ? page - 1 : 0;
+    const query = {};
+    const cacheOptions = {
+      page,
+      limit
+    };
     try {
-      _id = new import_mongodb8.ObjectId(_id);
+      query._id = new import_mongodb8.ObjectId(_id);
+      cacheOptions._id = _id.toString();
     } catch (error) {
-      throw new import_node_server_utils13.BadRequestError("Invalid area ID format.");
+      throw new import_node_server_utils13.BadRequestError("Invalid area checklist ID format.");
     }
-    try {
-      acceptedBy = new import_mongodb8.ObjectId(acceptedBy);
-    } catch (error) {
-      throw new import_node_server_utils13.BadRequestError("Invalid acceptedBy ID format.");
+    if (search) {
+      query.$text = { $search: search };
+      cacheOptions.search = search;
+    }
+    const cacheKey = (0, import_node_server_utils13.makeCacheKey)(namespace_collection, cacheOptions);
+    if (!session) {
+      const cachedData = await getCache(cacheKey);
+      if (cachedData) {
+        import_node_server_utils13.logger.info(`Cache hit for key: ${cacheKey}`);
+        return cachedData;
+      }
     }
     try {
-      const now = /* @__PURE__ */ new Date();
-      const updateValue = {
-        metadata: {
-          acceptedBy,
-          acceptedAt: now
+      const pipeline = [
+        { $match: query },
+        {
+          $unwind: {
+            path: "$checklist",
+            preserveNullAndEmptyArrays: false
+          }
         },
-        updatedAt: now
-      };
-      const res = await collection.updateOne({ _id }, { $set: updateValue });
-      if (res.modifiedCount === 0) {
-        throw new import_node_server_utils13.InternalServerError("Unable to update cleaning area.");
-      }
-      delNamespace().then(() => {
-        import_node_server_utils13.logger.info(`Cache cleared for namespace: ${namespace_collection}`);
+        {
+          $unwind: {
+            path: "$checklist.units",
+            preserveNullAndEmptyArrays: false
+          }
+        },
+        {
+          $project: {
+            _id: 0,
+            set: "$checklist.set",
+            unit: "$checklist.units.unit",
+            name: "$checklist.units.name",
+            status: {
+              $switch: {
+                branches: [
+                  {
+                    case: { $eq: ["$checklist.units.status", "ready"] },
+                    then: "Ready"
+                  },
+                  {
+                    case: { $eq: ["$checklist.units.status", "completed"] },
+                    then: "Completed"
+                  }
+                ],
+                default: "$checklist.units.status"
+              }
+            },
+            remarks: "$checklist.units.remarks"
+          }
+        },
+        { $sort: { set: 1, name: 1 } },
+        {
+          $group: {
+            _id: "$set",
+            units: {
+              $push: {
+                unit: "$unit",
+                name: "$name",
+                status: "$status",
+                remarks: "$remarks"
+              }
+            }
+          }
+        },
+        {
+          $project: {
+            _id: 0,
+            set: "$_id",
+            units: 1
+          }
+        },
+        { $sort: { set: 1 } },
+        { $skip: page * limit },
+        { $limit: limit }
+      ];
+      const countPipeline = [
+        { $match: query },
+        {
+          $unwind: {
+            path: "$checklist",
+            preserveNullAndEmptyArrays: false
+          }
+        },
+        {
+          $group: {
+            _id: "$checklist.set"
+          }
+        },
+        { $count: "total" }
+      ];
+      const [items, countResult] = await Promise.all([
+        collection.aggregate(pipeline, { session }).toArray(),
+        collection.aggregate(countPipeline, { session }).toArray()
+      ]);
+      const length = countResult.length > 0 ? countResult[0].total : 0;
+      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 clear cache for namespace: ${namespace_collection}`,
-          err
-        );
+        import_node_server_utils13.logger.error(`Failed to set cache for key: ${cacheKey}`, err);
       });
-      return res.modifiedCount;
+      return data;
     } catch (error) {
       throw error;
     }
   }
-  async function attachImageAreaChecklist(_id, attachments, session) {
+  async function completeAreaChecklistUnits(_id, set, unitId, value, session) {
     try {
       _id = new import_mongodb8.ObjectId(_id);
     } catch (error) {
       throw new import_node_server_utils13.BadRequestError("Invalid area checklist ID format.");
     }
+    try {
+      unitId = new import_mongodb8.ObjectId(unitId);
+    } catch (error) {
+      throw new import_node_server_utils13.BadRequestError("Invalid unit checklist ID format.");
+    }
     try {
       const now = /* @__PURE__ */ new Date();
       const updateValue = {
-        metadata: { attachments },
+        "checklist.$[checklist].units.$[unit].timestamp": now,
+        "checklist.$[checklist].units.$[unit].status": "completed",
         updatedAt: now
       };
+      if (value.remarks) {
+        updateValue["checklist.$[checklist].units.$[unit].remarks"] = value.remarks;
+      }
+      if (value.completedBy) {
+        updateValue["checklist.$[checklist].units.$[unit].completedBy"] = new import_mongodb8.ObjectId(value.completedBy);
+      }
+      const arrayFilters = [
+        { "checklist.set": set, "checklist.units.unit": unitId },
+        { "unit.unit": unitId }
+      ];
       const res = await collection.updateOne(
-        { _id },
+        { _id, "checklist.set": set, "checklist.units.unit": unitId },
         { $set: updateValue },
-        { session }
+        { arrayFilters, session }
       );
       if (res.modifiedCount === 0) {
-        throw new import_node_server_utils13.InternalServerError(
-          "Unable to update cleaning area checklist."
-        );
+        throw new import_node_server_utils13.InternalServerError("Unable to update area checklist unit.");
       }
       delNamespace().then(() => {
         import_node_server_utils13.logger.info(`Cache cleared for namespace: ${namespace_collection}`);
@@ -2243,40 +2316,35 @@ function useAreaChecklistRepo() {
           err
         );
       });
-      delUnitNamespace().then(() => {
-        import_node_server_utils13.logger.info(
-          `Cache cleared for namespace: ${unit_checklist_collection}`
-        );
-      }).catch((err) => {
-        import_node_server_utils13.logger.error(
-          `Failed to clear cache for namespace: ${unit_checklist_collection}`,
-          err
-        );
-      });
       return res.modifiedCount;
     } catch (error) {
+      import_node_server_utils13.logger.error("Error updating area checklist unit:", error.message);
       throw error;
     }
   }
-  async function submitAreaChecklist(_id, signature) {
+  async function updateAreaChecklistStatus(_id, status, session) {
     try {
       _id = new import_mongodb8.ObjectId(_id);
     } catch (error) {
-      throw new import_node_server_utils13.BadRequestError("Invalid area ID format.");
+      throw new import_node_server_utils13.BadRequestError("Invalid area checklist ID format.");
     }
     try {
-      const now = /* @__PURE__ */ new Date();
       const updateValue = {
-        metadata: {
-          signature,
-          completedAt: now
-        },
-        status: "ongoing",
-        updatedAt: now
+        status,
+        updatedAt: /* @__PURE__ */ new Date()
       };
-      const res = await collection.updateOne({ _id }, { $set: updateValue });
+      if (status === "completed") {
+        updateValue.completedAt = /* @__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 update cleaning area.");
+        throw new import_node_server_utils13.InternalServerError(
+          "Unable to update area checklist status."
+        );
       }
       delNamespace().then(() => {
         import_node_server_utils13.logger.info(`Cache cleared for namespace: ${namespace_collection}`);
@@ -2291,35 +2359,21 @@ function useAreaChecklistRepo() {
       throw error;
     }
   }
-  async function completeAreaChecklist(_id, signature) {
+  async function getAreaChecklistById(_id, session) {
     try {
       _id = new import_mongodb8.ObjectId(_id);
     } catch (error) {
-      throw new import_node_server_utils13.BadRequestError("Invalid area ID format.");
+      throw new import_node_server_utils13.BadRequestError("Invalid area checklist ID format.");
     }
     try {
-      const now = /* @__PURE__ */ new Date();
-      const updateValue = {
-        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_utils13.InternalServerError("Unable to update cleaning area.");
+      const area = await collection.findOne(
+        { _id },
+        { projection: { schedule: 1, name: 1, type: 1, status: 1 }, session }
+      );
+      if (!area) {
+        throw new import_node_server_utils13.BadRequestError("Area checklist not found.");
       }
-      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;
+      return area;
     } catch (error) {
       throw error;
     }
@@ -2331,22 +2385,25 @@ function useAreaChecklistRepo() {
     getAllAreaChecklist,
     getAreaChecklistHistory,
     getAreaChecklistHistoryDetails,
-    acceptAreaChecklist,
-    attachImageAreaChecklist,
-    submitAreaChecklist,
-    completeAreaChecklist
+    getAreaChecklistUnits,
+    getAreaChecklistById,
+    updateAreaChecklistStatus,
+    completeAreaChecklistUnits
   };
 }
 
-// src/controllers/hygiene-area-checklist.controller.ts
-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_utils14 = require("@iservice365/node-server-utils");
 function useAreaChecklistService() {
-  const { createAreaChecklist: _createAreaChecklist } = useAreaChecklistRepo();
+  const {
+    createAreaChecklist: _createAreaChecklist,
+    getAllAreaChecklist,
+    getAreaChecklistUnits,
+    getAreaChecklistById,
+    completeAreaChecklistUnits: _completeAreaChecklistUnits,
+    updateAreaChecklistStatus
+  } = useAreaChecklistRepo();
   const { getAreasForChecklist } = useAreaRepo();
+  const { updateParentChecklistStatuses } = useParentChecklistRepo();
   async function createAreaChecklist(value) {
     const session = import_node_server_utils14.useAtlas.getClient()?.startSession();
     try {
@@ -2367,14 +2424,13 @@ function useAreaChecklistService() {
               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
-                  }))
-                }
-              ] : []
+              checklist: area.units && area.units.length > 0 ? Array.from({ length: area.set || 1 }, (_, index) => ({
+                set: index + 1,
+                units: area.units.map((unit) => ({
+                  unit: unit.unit.toString(),
+                  name: unit.name
+                }))
+              })) : []
             };
             const insertedId = await _createAreaChecklist(
               checklistData,
@@ -2405,14 +2461,16 @@ function useAreaChecklistService() {
               schedule: value.schedule,
               name: toiletLocation.name,
               type: "toilet",
-              checklist: toiletLocation.units && toiletLocation.units.length > 0 ? [
-                {
-                  set: toiletLocation.set || 0,
+              checklist: toiletLocation.units && toiletLocation.units.length > 0 ? Array.from(
+                { length: toiletLocation.set || 1 },
+                (_, index) => ({
+                  set: index + 1,
                   units: toiletLocation.units.map((unit) => ({
+                    unit: unit.unit.toString(),
                     name: unit.name
                   }))
-                }
-              ] : []
+                })
+              ) : []
             };
             const insertedId = await _createAreaChecklist(
               checklistData,
@@ -2445,21 +2503,107 @@ function useAreaChecklistService() {
       session?.endSession();
     }
   }
-  return { createAreaChecklist };
+  async function completeAreaChecklistUnits(_id, set, unitId, value) {
+    const session = import_node_server_utils14.useAtlas.getClient()?.startSession();
+    try {
+      session?.startTransaction();
+      await _completeAreaChecklistUnits(_id, set, unitId, value, session);
+      const allUnitsResult = await getAreaChecklistUnits(
+        {
+          page: 1,
+          limit: 1e3,
+          _id: _id.toString()
+        },
+        session
+      );
+      let areaStatus = "ready";
+      if (allUnitsResult && allUnitsResult.items && allUnitsResult.items.length > 0) {
+        const sets = allUnitsResult.items;
+        const allUnits = sets.flatMap((set2) => set2.units || []);
+        const readyCount = allUnits.filter(
+          (unit) => unit.status === "Ready"
+        ).length;
+        const completedCount = allUnits.filter(
+          (unit) => unit.status === "Completed"
+        ).length;
+        const totalCount = allUnits.length;
+        if (completedCount === totalCount) {
+          areaStatus = "completed";
+        } else if (readyCount === totalCount) {
+          areaStatus = "ready";
+        } else {
+          areaStatus = "ongoing";
+        }
+      }
+      await updateAreaChecklistStatus(_id, areaStatus, session);
+      const currentArea = await getAreaChecklistById(_id, session);
+      const scheduleId = currentArea.schedule;
+      if (scheduleId) {
+        const allAreasResult = await getAllAreaChecklist(
+          {
+            page: 1,
+            limit: 1e3,
+            schedule: scheduleId.toString()
+          },
+          session
+        );
+        if (allAreasResult && allAreasResult.items && allAreasResult.items.length > 0) {
+          const areas = allAreasResult.items;
+          const readyAreasCount = areas.filter(
+            (area) => area.status === "Ready"
+          ).length;
+          const completedAreasCount = areas.filter(
+            (area) => area.status === "Completed"
+          ).length;
+          const totalAreasCount = areas.length;
+          let parentStatus = "ready";
+          if (completedAreasCount === totalAreasCount) {
+            parentStatus = "completed";
+          } else if (readyAreasCount === totalAreasCount) {
+            parentStatus = "ready";
+          } else {
+            parentStatus = "ongoing";
+          }
+          await updateParentChecklistStatuses(
+            scheduleId,
+            parentStatus,
+            session
+          );
+        } else {
+          import_node_server_utils14.logger.info(
+            "No area checklists found, keeping parent status as ready"
+          );
+        }
+      }
+      await session?.commitTransaction();
+      return;
+    } catch (error) {
+      import_node_server_utils14.logger.error(`Error updating area checklist unit and statuses:`, error);
+      if (session?.inTransaction()) {
+        await session?.abortTransaction();
+      }
+      throw error;
+    } finally {
+      session?.endSession();
+    }
+  }
+  return { createAreaChecklist, completeAreaChecklistUnits };
 }
 
 // src/controllers/hygiene-area-checklist.controller.ts
+var import_node_server_utils15 = require("@iservice365/node-server-utils");
+var import_joi8 = __toESM(require("joi"));
 function useAreaChecklistController() {
   const {
     getAllAreaChecklist: _getAllAreaChecklist,
     getAreaChecklistHistory: _getAreaChecklistHistory,
     getAreaChecklistHistoryDetails: _getAreaChecklistHistoryDetails,
-    acceptAreaChecklist: _acceptAreaChecklist,
-    attachImageAreaChecklist: _attachImageAreaChecklist,
-    submitAreaChecklist: _submitAreaChecklist,
-    completeAreaChecklist: _completeAreaChecklist
+    getAreaChecklistUnits: _getAreaChecklistUnits
   } = useAreaChecklistRepo();
-  const { createAreaChecklist: _createAreaChecklist } = useAreaChecklistService();
+  const {
+    createAreaChecklist: _createAreaChecklist,
+    completeAreaChecklistUnits: _completeAreaChecklistUnits
+  } = useAreaChecklistService();
   async function createAreaChecklist(req, res, next) {
     const payload = {
       site: req.params.site,
@@ -2522,22 +2666,15 @@ function useAreaChecklistController() {
     }
   }
   async function getAreaChecklistHistory(req, res, next) {
-    const cookies = req.headers.cookie ? req.headers.cookie.split(";").map((cookie) => cookie.trim().split("=")).reduce(
-      (acc, [key, value]) => ({ ...acc, [key]: value }),
-      {}
-    ) : {};
-    const user = cookies["user"] || "";
-    const query = { ...req.query, ...req.params, user };
+    const query = { ...req.query, ...req.params };
     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(),
+      type: import_joi8.default.string().optional().allow("", ...allowedTypes),
       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)
+      createdAt: import_joi8.default.alternatives().try(import_joi8.default.date(), import_joi8.default.string()).optional().allow("", null)
     });
     const { error } = validation.validate(query);
     if (error) {
@@ -2548,7 +2685,6 @@ function useAreaChecklistController() {
     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.query.type ?? "";
     const schedule = req.params.schedule ?? "";
     const status = req.query.status ?? "";
@@ -2558,12 +2694,10 @@ function useAreaChecklistController() {
         page,
         limit,
         search,
-        site,
         type,
         schedule,
         status,
-        createdAt,
-        user
+        createdAt
       });
       res.json(data);
       return;
@@ -2592,70 +2726,32 @@ function useAreaChecklistController() {
       return;
     }
   }
-  async function acceptAreaChecklist(req, res, next) {
-    const cookies = req.headers.cookie ? req.headers.cookie.split(";").map((cookie) => cookie.trim().split("=")).reduce(
-      (acc, [key, value]) => ({ ...acc, [key]: value }),
-      {}
-    ) : {};
-    const acceptedBy = cookies["user"] || "";
-    const payload = { id: req.params.id, acceptedBy };
-    const validation = import_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_utils15.logger.log({ level: "error", message: error.message });
-      next(new import_node_server_utils15.BadRequestError(error.message));
-      return;
-    }
-    try {
-      await _acceptAreaChecklist(payload.id, payload.acceptedBy);
-      res.json({ message: "Area checklist updated successfully." });
-      return;
-    } catch (error2) {
-      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_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_utils15.logger.log({ level: "error", message: error.message });
-      next(new import_node_server_utils15.BadRequestError(error.message));
-      return;
-    }
-    try {
-      await _attachImageAreaChecklist(payload.id, payload.attachments);
-      res.json({ message: "Area checklist attachments updated successfully." });
-      return;
-    } catch (error2) {
-      import_node_server_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 };
+  async function getAreaChecklistUnits(req, res, next) {
+    const query = { ...req.query, ...req.params };
     const validation = import_joi8.default.object({
-      id: import_joi8.default.string().hex().required(),
-      signature: import_joi8.default.string().required()
+      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),
+      id: import_joi8.default.string().hex().required()
     });
-    const { error } = validation.validate(payload);
+    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 _id = req.params.id ?? "";
     try {
-      await _submitAreaChecklist(payload.id, payload.signature);
-      res.json({ message: "Area checklist submitted successfully." });
+      const data = await _getAreaChecklistUnits({
+        page,
+        limit,
+        search,
+        _id
+      });
+      res.json(data);
       return;
     } catch (error2) {
       import_node_server_utils15.logger.log({ level: "error", message: error2.message });
@@ -2663,11 +2759,23 @@ function useAreaChecklistController() {
       return;
     }
   }
-  async function completeAreaChecklist(req, res, next) {
-    const payload = { id: req.params.id, signature: req.body.signature };
+  async function completeAreaChecklistUnits(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 completedBy = cookies["user"] || "";
+    const payload = {
+      ...req.params,
+      ...req.body,
+      completedBy
+    };
     const validation = import_joi8.default.object({
       id: import_joi8.default.string().hex().required(),
-      signature: import_joi8.default.string().required()
+      set: import_joi8.default.number().integer().min(1).required(),
+      unit: import_joi8.default.string().hex().required(),
+      remarks: import_joi8.default.string().optional().allow("", null),
+      completedBy: import_joi8.default.string().hex().required()
     });
     const { error } = validation.validate(payload);
     if (error) {
@@ -2676,8 +2784,14 @@ function useAreaChecklistController() {
       return;
     }
     try {
-      await _completeAreaChecklist(payload.id, payload.signature);
-      res.json({ message: "Area checklist completed successfully." });
+      const { id, set, unit, ...value } = payload;
+      await _completeAreaChecklistUnits(
+        id,
+        parseInt(set),
+        unit,
+        value
+      );
+      res.json({ message: "Area checklist updated successfully." });
       return;
     } catch (error2) {
       import_node_server_utils15.logger.log({ level: "error", message: error2.message });
@@ -2690,30 +2804,25 @@ function useAreaChecklistController() {
     getAllAreaChecklist,
     getAreaChecklistHistory,
     getAreaChecklistHistoryDetails,
-    acceptAreaChecklist,
-    attachImageAreaChecklist,
-    submitAreaChecklist,
-    completeAreaChecklist
+    getAreaChecklistUnits,
+    completeAreaChecklistUnits
   };
 }
 
-// src/models/hygiene-unit-checklist.model.ts
+// src/models/hygiene-supply.model.ts
 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({
+var supplySchema = 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)
+  name: import_joi9.default.string().required(),
+  unitOfMeasurement: import_joi9.default.string().required(),
+  qty: import_joi9.default.number().min(0).required()
 });
-function MUnitChecklist(value) {
-  const { error } = unitChecklistSchema.validate(value);
+function MSupply(value) {
+  const { error } = supplySchema.validate(value);
   if (error) {
-    import_node_server_utils16.logger.info(`Hygiene Checklist Unit Model: ${error.message}`);
+    import_node_server_utils16.logger.info(`Hygiene Supply Model: ${error.message}`);
     throw new import_node_server_utils16.BadRequestError(error.message);
   }
   if (value.site) {
@@ -2723,76 +2832,35 @@ function MUnitChecklist(value) {
       throw new import_node_server_utils16.BadRequestError("Invalid site ID format.");
     }
   }
-  if (value.parentChecklist) {
-    try {
-      value.parentChecklist = new import_mongodb9.ObjectId(value.parentChecklist);
-    } catch (error2) {
-      throw new import_node_server_utils16.BadRequestError("Invalid parent checklist ID format.");
-    }
-  }
-  if (value.areaChecklist) {
-    try {
-      value.areaChecklist = new import_mongodb9.ObjectId(value.areaChecklist);
-    } catch (error2) {
-      throw new import_node_server_utils16.BadRequestError("Invalid area checklist ID format.");
-    }
-  }
-  if (value.unit) {
-    try {
-      value.unit = new import_mongodb9.ObjectId(value.unit);
-    } catch (error2) {
-      throw new import_node_server_utils16.BadRequestError("Invalid unit 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.");
-    }
-  }
   return {
     site: value.site,
-    type: value.type,
-    parentChecklist: value.parentChecklist,
-    areaChecklist: value.areaChecklist,
-    unit: value.unit,
-    name: value.name ?? "",
-    approve: false,
-    reject: false,
-    createdBy: value.createdBy ?? "",
+    name: value.name,
+    unitOfMeasurement: value.unitOfMeasurement,
+    qty: value.qty,
     createdAt: /* @__PURE__ */ new Date(),
-    updatedAt: value.updatedAt ?? ""
+    status: "active",
+    updatedAt: "",
+    deletedAt: ""
   };
 }
 
-// src/repositories/hygiene-unit-checklist.repository.ts
-var import_node_server_utils17 = require("@iservice365/node-server-utils");
+// src/repositories/hygiene-supply.repository.ts
 var import_mongodb10 = require("mongodb");
-function useUnitChecklistRepo() {
+var import_node_server_utils17 = require("@iservice365/node-server-utils");
+function useSupplyRepository() {
   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-checklist.units";
+  const namespace_collection = "site.supplies";
   const collection = db.collection(namespace_collection);
   const { delNamespace, setCache, getCache } = (0, import_node_server_utils17.useCache)(namespace_collection);
   async function createIndex() {
     try {
-      await collection.createIndexes([
-        { key: { site: 1 } },
-        { key: { type: 1 } },
-        { key: { parentChecklist: 1 } },
-        { key: { areaChecklist: 1 } },
-        { key: { "metadata.workOrder.category": 1 } },
-        { key: { "metadata.workOrder.createdBy": 1 } },
-        { key: { "metadata.workOrder.serviceProvider": 1 } },
-        { key: { "metadata.workOrder.organization": 1 } },
-        { key: { "metadata.workOrder.site": 1 } }
-      ]);
+      await collection.createIndexes([{ key: { site: 1 } }]);
     } catch (error) {
       throw new import_node_server_utils17.InternalServerError(
-        "Failed to create index on hygiene unit checklist."
+        "Failed to create index on hygiene supply."
       );
     }
   }
@@ -2801,13 +2869,25 @@ function useUnitChecklistRepo() {
       await collection.createIndex({ name: "text" });
     } catch (error) {
       throw new import_node_server_utils17.InternalServerError(
-        "Failed to create text index on hygiene unit checklist."
+        "Failed to create text index on hygiene supply."
       );
     }
   }
-  async function createUnitChecklist(value, session) {
+  async function createUniqueIndex() {
     try {
-      value = MUnitChecklist(value);
+      await collection.createIndex(
+        { site: 1, name: 1, deletedAt: 1 },
+        { unique: true }
+      );
+    } catch (error) {
+      throw new import_node_server_utils17.InternalServerError(
+        "Failed to create unique index on hygiene supply."
+      );
+    }
+  }
+  async function createSupply(value, session) {
+    try {
+      value = MSupply(value);
       const res = await collection.insertOne(value, { session });
       delNamespace().then(() => {
         import_node_server_utils17.logger.info(`Cache cleared for namespace: ${namespace_collection}`);
@@ -2819,42 +2899,34 @@ function useUnitChecklistRepo() {
       });
       return res.insertedId;
     } catch (error) {
+      const isDuplicated = error.message.includes("duplicate");
+      if (isDuplicated) {
+        throw new import_node_server_utils17.BadRequestError("Supply already exists.");
+      }
       throw error;
     }
   }
-  async function getAllUnitChecklist({
+  async function getSupplies({
     page = 1,
     limit = 10,
     search = "",
-    site,
-    type,
-    parentChecklist,
-    areaChecklist
+    site
   }) {
     page = page > 0 ? page - 1 : 0;
-    const query = { type };
+    const query = {
+      status: { $ne: "deleted" }
+    };
     const cacheOptions = {
       page,
       limit
     };
     try {
-      query.site = new import_mongodb10.ObjectId(site);
+      site = new import_mongodb10.ObjectId(site);
+      query.site = site;
       cacheOptions.site = site.toString();
     } catch (error) {
       throw new import_node_server_utils17.BadRequestError("Invalid site ID format.");
     }
-    try {
-      query.parentChecklist = new import_mongodb10.ObjectId(parentChecklist);
-      cacheOptions.parentChecklist = parentChecklist.toString();
-    } catch (error) {
-      throw new import_node_server_utils17.BadRequestError("Invalid parent checklist ID format.");
-    }
-    try {
-      query.areaChecklist = new import_mongodb10.ObjectId(areaChecklist);
-      cacheOptions.areaChecklist = areaChecklist.toString();
-    } catch (error) {
-      throw new import_node_server_utils17.BadRequestError("Invalid area checklist ID format.");
-    }
     if (search) {
       query.$text = { $search: search };
       cacheOptions.search = search;
@@ -2866,120 +2938,20 @@ function useUnitChecklistRepo() {
       return cachedData;
     }
     try {
-      const areaAttachmentsResult = await collection.aggregate([
-        { $match: query },
-        {
-          $lookup: {
-            from: "hygiene-checklist.areas",
-            localField: "areaChecklist",
-            foreignField: "_id",
-            pipeline: [
-              { $project: { attachments: "$metadata.attachments" } }
-            ],
-            as: "areaChecklistData"
-          }
-        },
-        {
-          $unwind: {
-            path: "$areaChecklistData",
-            preserveNullAndEmptyArrays: true
-          }
-        },
-        {
-          $group: {
-            _id: null,
-            attachments: { $first: "$areaChecklistData.attachments" }
-          }
-        }
-      ]).toArray();
-      const areaAttachments = areaAttachmentsResult.length > 0 ? areaAttachmentsResult[0].attachments || [] : [];
-      const pipeline = [
+      const items = await collection.aggregate([
         { $match: query },
-        {
-          $lookup: {
-            from: "organizations",
-            localField: "metadata.workOrder.category",
-            foreignField: "_id",
-            pipeline: [{ $project: { nature: 1 } }],
-            as: "categoryData"
-          }
-        },
-        {
-          $lookup: {
-            from: "users",
-            localField: "metadata.workOrder.createdBy",
-            foreignField: "_id",
-            pipeline: [{ $project: { name: 1 } }],
-            as: "createdByData"
-          }
-        },
-        {
-          $lookup: {
-            from: "service-providers",
-            localField: "metadata.workOrder.serviceProvider",
-            foreignField: "_id",
-            pipeline: [{ $project: { name: 1 } }],
-            as: "serviceProviderData"
-          }
-        },
-        {
-          $lookup: {
-            from: "organizations",
-            localField: "metadata.workOrder.organization",
-            foreignField: "_id",
-            pipeline: [{ $project: { name: 1 } }],
-            as: "organizationData"
-          }
-        },
-        {
-          $lookup: {
-            from: "sites",
-            localField: "metadata.workOrder.site",
-            foreignField: "_id",
-            pipeline: [{ $project: { name: 1 } }],
-            as: "siteData"
-          }
-        },
-        {
-          $addFields: {
-            "metadata.workOrder.categoryName": {
-              $arrayElemAt: ["$categoryData.nature", 0]
-            },
-            "metadata.workOrder.createdByName": {
-              $arrayElemAt: ["$createdByData.name", 0]
-            },
-            "metadata.workOrder.serviceProviderName": {
-              $arrayElemAt: ["$serviceProviderData.name", 0]
-            },
-            "metadata.workOrder.organizationName": {
-              $arrayElemAt: ["$organizationData.name", 0]
-            },
-            "metadata.workOrder.siteName": {
-              $arrayElemAt: ["$siteData.name", 0]
-            }
-          }
-        },
         {
           $project: {
             name: 1,
-            remarks: "$metadata.remarks",
-            attachments: "$metadata.attachments",
-            workOrder: "$metadata.workOrder",
-            approve: { $ifNull: ["$approve", null] },
-            reject: { $ifNull: ["$reject", null] }
+            qty: 1
           }
         },
         { $sort: { _id: -1 } },
         { $skip: page * limit },
         { $limit: limit }
-      ];
-      const items = await collection.aggregate(pipeline).toArray();
+      ]).toArray();
       const length = await collection.countDocuments(query);
-      const paginatedData = (0, import_node_server_utils17.paginate)(items, page, limit, length);
-      const data = {
-        attachments: areaAttachments,
-        ...paginatedData
-      };
+      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) => {
@@ -2990,78 +2962,58 @@ function useUnitChecklistRepo() {
       throw error;
     }
   }
-  async function getUnitChecklistById(_id) {
+  async function updateSupply(_id, value, session) {
     try {
       _id = new import_mongodb10.ObjectId(_id);
     } catch (error) {
-      throw new import_node_server_utils17.BadRequestError("Invalid unit checklist ID format.");
+      throw new import_node_server_utils17.BadRequestError("Invalid supply ID format.");
     }
     try {
-      return await collection.findOne({ _id });
+      const updateValue = { ...value, updatedAt: /* @__PURE__ */ new Date() };
+      const res = await collection.updateOne(
+        { _id },
+        { $set: updateValue },
+        { session }
+      );
+      if (res.modifiedCount === 0) {
+        throw new import_node_server_utils17.InternalServerError("Unable to update cleaning supply.");
+      }
+      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 updateUnitChecklist(_id, value, session) {
+  async function deleteSupply(_id, session) {
     try {
       _id = new import_mongodb10.ObjectId(_id);
     } catch (error) {
-      throw new import_node_server_utils17.BadRequestError("Invalid unit checklist ID format.");
-    }
-    if (value.checkedBy && typeof value.checkedBy === "string") {
-      try {
-        value.checkedBy = new import_mongodb10.ObjectId(value.checkedBy);
-      } catch (error) {
-        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_mongodb10.ObjectId(workOrder.category);
-        } catch (error) {
-          throw new import_node_server_utils17.BadRequestError("Invalid category ID format.");
-        }
-      }
-      if (workOrder.createdBy && typeof workOrder.createdBy === "string") {
-        try {
-          workOrder.createdBy = new import_mongodb10.ObjectId(workOrder.createdBy);
-        } catch (error) {
-          throw new import_node_server_utils17.BadRequestError("Invalid createdBy ID format.");
-        }
-      }
-      if (workOrder.serviceProvider && typeof workOrder.serviceProvider === "string") {
-        try {
-          workOrder.serviceProvider = new import_mongodb10.ObjectId(workOrder.serviceProvider);
-        } catch (error) {
-          throw new import_node_server_utils17.BadRequestError("Invalid serviceProvider ID format.");
-        }
-      }
-      if (workOrder.organization && typeof workOrder.organization === "string") {
-        try {
-          workOrder.organization = new import_mongodb10.ObjectId(workOrder.organization);
-        } catch (error) {
-          throw new import_node_server_utils17.BadRequestError("Invalid organization ID format.");
-        }
-      }
-      if (workOrder.site && typeof workOrder.site === "string") {
-        try {
-          workOrder.site = new import_mongodb10.ObjectId(workOrder.site);
-        } catch (error) {
-          throw new import_node_server_utils17.BadRequestError("Invalid site ID format.");
-        }
-      }
+      throw new import_node_server_utils17.BadRequestError("Invalid supply ID format.");
     }
     try {
-      const updateValue = { ...value, updatedAt: /* @__PURE__ */ new Date() };
+      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 update unit checklist.");
+        throw new import_node_server_utils17.InternalServerError("Unable to delete supply.");
       }
       delNamespace().then(() => {
         import_node_server_utils17.logger.info(`Cache cleared for namespace: ${namespace_collection}`);
@@ -3079,236 +3031,126 @@ function useUnitChecklistRepo() {
   return {
     createIndex,
     createTextIndex,
-    createUnitChecklist,
-    getAllUnitChecklist,
-    getUnitChecklistById,
-    updateUnitChecklist
+    createUniqueIndex,
+    createSupply,
+    getSupplies,
+    updateSupply,
+    deleteSupply
   };
 }
 
-// src/controllers/hygiene-unit-checklist.controller.ts
-var import_node_server_utils19 = require("@iservice365/node-server-utils");
-var import_joi10 = __toESM(require("joi"));
-
-// src/services/hygiene-unit-checklist.service.ts
+// src/controllers/hygiene-supply.controller.ts
 var import_node_server_utils18 = require("@iservice365/node-server-utils");
-var import_core = require("@iservice365/core");
-function useUnitChecklistService() {
-  const {
-    getUnitChecklistById: _getUnitChecklistById,
-    updateUnitChecklist: _updateUnitChecklist
-  } = useUnitChecklistRepo();
-  const { getSiteById } = (0, import_core.useSiteRepo)();
-  const { createWorkOrder } = (0, import_core.useWorkOrderService)();
-  async function approveUnitChecklist(id, value) {
-    try {
-      value.approve = true;
-      value.reject = false;
-      const result = await _updateUnitChecklist(id, value);
-      return result;
-    } catch (error) {
-      import_node_server_utils18.logger.error(`Error updating unit checklist with id ${id}:`, error);
-      throw error;
-    }
-  }
-  async function rejectUnitChecklist(id, value, fullHost) {
-    try {
-      value.reject = true;
-      value.approve = false;
-      if (value.metadata?.workOrder) {
-        const existingChecklist = await _getUnitChecklistById(id);
-        if (!existingChecklist)
-          throw new import_node_server_utils18.NotFoundError("Unit checklist not found.");
-        const site = await getSiteById(
-          existingChecklist.site
-        );
-        if (!site)
-          throw new import_node_server_utils18.NotFoundError("Site not found.");
-        const workOrderData = {
-          ...value.metadata.workOrder,
-          attachments: value.metadata.attachments,
-          createdBy: value.checkedBy,
-          organization: site.orgId,
-          site: site._id
-        };
-        const workOrder = await createWorkOrder(
-          workOrderData,
-          fullHost
-        );
-        if (!workOrder)
-          throw new import_node_server_utils18.NotFoundError("Failed to create work order.");
-      }
-      const result = await _updateUnitChecklist(id, value);
-      return result;
-    } catch (error) {
-      import_node_server_utils18.logger.error(`Error updating unit checklist with id ${id}:`, error);
-      throw error;
-    }
-  }
-  return {
-    approveUnitChecklist,
-    rejectUnitChecklist
-  };
-}
-
-// src/controllers/hygiene-unit-checklist.controller.ts
-var import_core2 = require("@iservice365/core");
-function useUnitChecklistController() {
-  const {
-    createUnitChecklist: _createUnitChecklist,
-    getAllUnitChecklist: _getAllUnitChecklist
-  } = useUnitChecklistRepo();
+var import_joi10 = __toESM(require("joi"));
+function useSupplyController() {
   const {
-    approveUnitChecklist: _approveUnitChecklist,
-    rejectUnitChecklist: _rejectUnitChecklist
-  } = useUnitChecklistService();
-  async function createUnitChecklist(req, res, next) {
-    const cookies = req.headers.cookie ? req.headers.cookie.split(";").map((cookie) => cookie.trim().split("=")).reduce(
-      (acc, [key, value]) => ({ ...acc, [key]: value }),
-      {}
-    ) : {};
-    const createdBy = cookies["user"] || "";
-    const payload = { ...req.body, ...req.params, createdBy };
-    const { error } = unitChecklistSchema.validate(payload);
+    createSupply: _createSupply,
+    getSupplies: _getSupplies,
+    updateSupply: _updateSupply,
+    deleteSupply: _deleteSupply
+  } = useSupplyRepository();
+  async function createSupply(req, res, next) {
+    const payload = { ...req.body, ...req.params };
+    const { error } = supplySchema.validate(payload);
     if (error) {
-      import_node_server_utils19.logger.log({ level: "error", message: error.message });
-      next(new import_node_server_utils19.BadRequestError(error.message));
+      import_node_server_utils18.logger.log({ level: "error", message: error.message });
+      next(new import_node_server_utils18.BadRequestError(error.message));
       return;
     }
     try {
-      const id = await _createUnitChecklist(payload);
-      res.status(201).json({ message: "Unit checklist created successfully.", id });
+      const id = await _createSupply(payload);
+      res.status(201).json({ message: "Supply created successfully.", id });
       return;
     } catch (error2) {
-      import_node_server_utils19.logger.log({ level: "error", message: error2.message });
+      import_node_server_utils18.logger.log({ level: "error", message: error2.message });
       next(error2);
       return;
     }
   }
-  async function getAllUnitChecklist(req, res, next) {
+  async function getSupplies(req, res, next) {
     const query = { ...req.query, ...req.params };
     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()
+      site: import_joi10.default.string().hex().required()
     });
     const { error } = validation.validate(query);
     if (error) {
-      import_node_server_utils19.logger.log({ level: "error", message: error.message });
-      next(new import_node_server_utils19.BadRequestError(error.message));
+      import_node_server_utils18.logger.log({ level: "error", message: error.message });
+      next(new import_node_server_utils18.BadRequestError(error.message));
       return;
     }
     const page = parseInt(req.query.page) ?? 1;
     const limit = parseInt(req.query.limit) ?? 20;
     const search = req.query.search ?? "";
     const site = req.params.site ?? "";
-    const type = req.params.type ?? "";
-    const parentChecklist = req.params.parentChecklist ?? "";
-    const areaChecklist = req.params.areaChecklist ?? "";
     try {
-      const data = await _getAllUnitChecklist({
+      const data = await _getSupplies({
         page,
         limit,
         search,
-        site,
-        type,
-        parentChecklist,
-        areaChecklist
+        site
       });
       res.json(data);
       return;
     } catch (error2) {
-      import_node_server_utils19.logger.log({ level: "error", message: error2.message });
+      import_node_server_utils18.logger.log({ level: "error", message: error2.message });
       next(error2);
       return;
     }
   }
-  async function approveUnitChecklist(req, res, next) {
-    const cookies = req.headers.cookie ? req.headers.cookie.split(";").map((cookie) => cookie.trim().split("=")).reduce(
-      (acc, [key, value]) => ({ ...acc, [key]: value }),
-      {}
-    ) : {};
-    const checkedBy = cookies["user"] || "";
-    const payload = { id: req.params.id, checkedBy };
+  async function updateSupply(req, res, next) {
+    const payload = { id: req.params.id, ...req.body };
     const validation = import_joi10.default.object({
       id: import_joi10.default.string().hex().required(),
-      checkedBy: import_joi10.default.string().hex().required()
+      name: import_joi10.default.string().optional().allow("", null),
+      unitOfMeasurement: import_joi10.default.string().optional().allow("", null),
+      qty: import_joi10.default.number().min(0).optional().allow("", null)
     });
     const { error } = validation.validate(payload);
     if (error) {
-      import_node_server_utils19.logger.log({ level: "error", message: error.message });
-      next(new import_node_server_utils19.BadRequestError(error.message));
+      import_node_server_utils18.logger.log({ level: "error", message: error.message });
+      next(new import_node_server_utils18.BadRequestError(error.message));
       return;
     }
     try {
       const { id, ...value } = payload;
-      await _approveUnitChecklist(id, value);
-      res.json({ message: "Unit checklist approved successfully." });
+      await _updateSupply(id, value);
+      res.json({ message: "Supply updated successfully." });
       return;
     } catch (error2) {
-      import_node_server_utils19.logger.log({ level: "error", message: error2.message });
+      import_node_server_utils18.logger.log({ level: "error", message: error2.message });
       next(error2);
       return;
     }
   }
-  async function rejectUnitChecklist(req, res, next) {
-    const cookies = req.headers.cookie ? req.headers.cookie.split(";").map((cookie) => cookie.trim().split("=")).reduce(
-      (acc, [key, value]) => ({ ...acc, [key]: value }),
-      {}
-    ) : {};
-    const checkedBy = cookies["user"] || "";
-    if (req.body.workOrder) {
-      req.body.workOrder.createdBy = checkedBy;
-    }
-    const payload = { id: req.params.id, checkedBy, ...req.body };
+  async function deleteSupply(req, res, next) {
+    const id = req.params.id;
     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_joi10.default.string().hex().required()
+      id: import_joi10.default.string().hex().required()
     });
-    const { error } = validation.validate(payload);
+    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));
+      import_node_server_utils18.logger.log({ level: "error", message: error.message });
+      next(new import_node_server_utils18.BadRequestError(error.message));
       return;
     }
     try {
-      const { id, attachments, remarks, workOrder, ...value } = payload;
-      value.metadata = {
-        attachments: attachments || [],
-        remarks: remarks || "",
-        workOrder
-      };
-      if (value.metadata.workOrder) {
-        if (value.metadata.workOrder.category) {
-          value.metadata.workOrder.category = value.metadata.workOrder.category;
-        }
-        if (value.metadata.workOrder.serviceProvider) {
-          value.metadata.workOrder.serviceProvider = value.metadata.workOrder.serviceProvider;
-        }
-        value.metadata.workOrder.createdBy = checkedBy;
-      }
-      const fullHost = req.headers.origin;
-      await _rejectUnitChecklist(id, value, fullHost);
-      res.json({ message: "Unit checklist rejected successfully." });
+      await _deleteSupply(id);
+      res.json({ message: "Supply deleted successfully." });
       return;
     } catch (error2) {
-      import_node_server_utils19.logger.log({ level: "error", message: error2.message });
+      import_node_server_utils18.logger.log({ level: "error", message: error2.message });
       next(error2);
       return;
     }
   }
   return {
-    createUnitChecklist,
-    getAllUnitChecklist,
-    approveUnitChecklist,
-    rejectUnitChecklist
+    createSupply,
+    getSupplies,
+    updateSupply,
+    deleteSupply
   };
 }
 // Annotate the CommonJS export names for ESM import in node:
@@ -3316,23 +3158,26 @@ function useUnitChecklistController() {
   MArea,
   MAreaChecklist,
   MParentChecklist,
+  MSupply,
   MUnit,
-  MUnitChecklist,
   allowedChecklistStatus,
+  allowedStatus,
+  allowedTypes,
   areaChecklistSchema,
   areaSchema,
   parentChecklistSchema,
-  unitChecklistSchema,
+  supplySchema,
   unitSchema,
   useAreaChecklistController,
   useAreaChecklistRepo,
+  useAreaChecklistService,
   useAreaController,
   useAreaRepo,
   useAreaService,
   useParentChecklistController,
   useParentChecklistRepo,
-  useUnitChecklistController,
-  useUnitChecklistRepo,
+  useSupplyController,
+  useSupplyRepository,
   useUnitController,
   useUnitRepository,
   useUnitService