@iservice365/module-hygiene 1.0.3 → 1.3.0

package/dist/index.js

@@ -33,15 +33,25 @@ __export(src_exports, {
   MArea: () => MArea,
   MAreaChecklist: () => MAreaChecklist,
   MParentChecklist: () => MParentChecklist,
+  MRequestItem: () => MRequestItem,
+  MScheduleTask: () => MScheduleTask,
   MStock: () => MStock,
   MSupply: () => MSupply,
   MUnit: () => MUnit,
   allowedChecklistStatus: () => allowedChecklistStatus,
+  allowedDays: () => allowedDays,
+  allowedFrequency: () => allowedFrequency,
+  allowedMonths: () => allowedMonths,
+  allowedQuarter: () => allowedQuarter,
+  allowedRequestItemStatus: () => allowedRequestItemStatus,
   allowedStatus: () => allowedStatus,
   allowedTypes: () => allowedTypes,
+  allowedWeekOfMonth: () => allowedWeekOfMonth,
   areaChecklistSchema: () => areaChecklistSchema,
   areaSchema: () => areaSchema,
   parentChecklistSchema: () => parentChecklistSchema,
+  requestItemSchema: () => requestItemSchema,
+  scheduleTaskSchema: () => scheduleTaskSchema,
   stockSchema: () => stockSchema,
   supplySchema: () => supplySchema,
   unitSchema: () => unitSchema,
@@ -53,12 +63,16 @@ __export(src_exports, {
   useAreaService: () => useAreaService,
   useParentChecklistController: () => useParentChecklistController,
   useParentChecklistRepo: () => useParentChecklistRepo,
+  useRequestItemController: () => useRequestItemController,
+  useRequestItemRepository: () => useRequestItemRepository,
+  useRequestItemService: () => useRequestItemService,
+  useScheduleTaskController: () => useScheduleTaskController,
+  useScheduleTaskRepository: () => useScheduleTaskRepository,
   useStockController: () => useStockController,
   useStockRepository: () => useStockRepository,
   useStockService: () => useStockService,
   useSupplyController: () => useSupplyController,
   useSupplyRepository: () => useSupplyRepository,
-  useSupplyService: () => useSupplyService,
   useUnitController: () => useUnitController,
   useUnitRepository: () => useUnitRepository,
   useUnitService: () => useUnitService
@@ -698,7 +712,7 @@ function useAreaController() {
       return;
     }
     const page = parseInt(req.query.page) ?? 1;
-    const limit = parseInt(req.query.limit) ?? 20;
+    const limit = parseInt(req.query.limit) ?? 10;
     const search = req.query.search ?? "";
     const site = req.params.site ?? "";
     try {
@@ -844,8 +858,8 @@ function MUnit(value) {
   return {
     site: value.site,
     name: value.name,
-    createdAt: /* @__PURE__ */ new Date(),
     status: "active",
+    createdAt: /* @__PURE__ */ new Date(),
     updatedAt: "",
     deletedAt: ""
   };
@@ -1234,7 +1248,7 @@ function useUnitController() {
       return;
     }
     const page = parseInt(req.query.page) ?? 1;
-    const limit = parseInt(req.query.limit) ?? 20;
+    const limit = parseInt(req.query.limit) ?? 10;
     const search = req.query.search ?? "";
     const site = req.params.site ?? "";
     try {
@@ -1536,6 +1550,9 @@ function useParentChecklistRepo() {
         status,
         updatedAt: /* @__PURE__ */ new Date()
       };
+      if (status === "completed") {
+        updateValue.completedAt = /* @__PURE__ */ new Date();
+      }
       const res = await collection.updateOne(
         { _id },
         { $set: updateValue },
@@ -1640,7 +1657,7 @@ function useParentChecklistController() {
       return;
     }
     const page = parseInt(req.query.page) ?? 1;
-    const limit = parseInt(req.query.limit) ?? 20;
+    const limit = parseInt(req.query.limit) ?? 10;
     const search = req.query.search ?? "";
     const site = req.params.site ?? "";
     const startDate = req.query.startDate ?? "";
@@ -2651,7 +2668,7 @@ function useAreaChecklistController() {
       return;
     }
     const page = parseInt(req.query.page) ?? 1;
-    const limit = parseInt(req.query.limit) ?? 20;
+    const limit = parseInt(req.query.limit) ?? 10;
     const search = req.query.search ?? "";
     const type = req.query.type ?? "";
     const schedule = req.params.schedule ?? "";
@@ -2689,7 +2706,7 @@ function useAreaChecklistController() {
       return;
     }
     const page = parseInt(req.query.page) ?? 1;
-    const limit = parseInt(req.query.limit) ?? 20;
+    const limit = parseInt(req.query.limit) ?? 10;
     const search = req.query.search ?? "";
     const type = req.query.type ?? "";
     const schedule = req.params.schedule ?? "";
@@ -2747,7 +2764,7 @@ function useAreaChecklistController() {
       return;
     }
     const page = parseInt(req.query.page) ?? 1;
-    const limit = parseInt(req.query.limit) ?? 20;
+    const limit = parseInt(req.query.limit) ?? 10;
     const search = req.query.search ?? "";
     const _id = req.params.id ?? "";
     try {
@@ -2822,8 +2839,7 @@ var import_mongodb9 = require("mongodb");
 var supplySchema = import_joi9.default.object({
   site: import_joi9.default.string().hex().required(),
   name: import_joi9.default.string().required(),
-  unitOfMeasurement: import_joi9.default.string().required(),
-  qty: import_joi9.default.number().min(0).required()
+  unitOfMeasurement: import_joi9.default.string().required()
 });
 function MSupply(value) {
   const { error } = supplySchema.validate(value);
@@ -2842,7 +2858,7 @@ function MSupply(value) {
     site: value.site,
     name: value.name,
     unitOfMeasurement: value.unitOfMeasurement,
-    qty: value.qty,
+    qty: 0,
     status: "active",
     createdAt: (/* @__PURE__ */ new Date()).toISOString(),
     updatedAt: "",
@@ -2949,7 +2965,8 @@ function useSupplyRepository() {
         {
           $project: {
             name: 1,
-            qty: 1
+            qty: 1,
+            status: 1
           }
         },
         { $sort: { _id: -1 } },
@@ -2968,7 +2985,7 @@ function useSupplyRepository() {
       throw error;
     }
   }
-  async function getSupplyById(_id) {
+  async function getSupplyById(_id, session) {
     try {
       _id = new import_mongodb10.ObjectId(_id);
     } catch (error) {
@@ -2981,10 +2998,14 @@ function useSupplyRepository() {
     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;
+    if (!session) {
+      const cachedData = await getCache(cacheKey);
+      if (cachedData) {
+        import_node_server_utils17.logger.info(`Cache hit for key: ${cacheKey}`);
+        return cachedData;
+      }
+    } else {
+      import_node_server_utils17.logger.info(`Skipping cache during transaction for key: ${cacheKey}`);
     }
     try {
       const data = await collection.aggregate([
@@ -3038,7 +3059,7 @@ function useSupplyRepository() {
     } catch (error) {
       const isDuplicated = error.message.includes("duplicate");
       if (isDuplicated) {
-        throw new import_node_server_utils17.BadRequestError("Area already exists.");
+        throw new import_node_server_utils17.BadRequestError("Supply already exists.");
       }
       throw error;
     }
@@ -3088,152 +3109,23 @@ function useSupplyRepository() {
   };
 }
 
-// src/services/hygiene-supply.service.ts
-var import_node_server_utils20 = require("@iservice365/node-server-utils");
-
-// src/models/hygiene-stock.model.ts
+// src/controllers/hygiene-supply.controller.ts
 var import_node_server_utils18 = require("@iservice365/node-server-utils");
 var import_joi10 = __toESM(require("joi"));
-var import_mongodb11 = require("mongodb");
-var stockSchema = import_joi10.default.object({
-  site: import_joi10.default.string().hex().required(),
-  supply: import_joi10.default.string().hex().required(),
-  in: import_joi10.default.number().min(0).optional(),
-  out: import_joi10.default.number().min(0).optional(),
-  balance: import_joi10.default.number().min(0).required(),
-  remarks: import_joi10.default.string().optional().allow("", null)
-});
-function MStock(value) {
-  const { error } = stockSchema.validate(value);
-  if (error) {
-    import_node_server_utils18.logger.info(`Hygiene Stock Model: ${error.message}`);
-    throw new import_node_server_utils18.BadRequestError(error.message);
-  }
-  if (value.site) {
-    try {
-      value.site = new import_mongodb11.ObjectId(value.site);
-    } catch (error2) {
-      throw new import_node_server_utils18.BadRequestError("Invalid site ID format.");
-    }
-  }
-  if (value.supply) {
-    try {
-      value.supply = new import_mongodb11.ObjectId(value.supply);
-    } catch (error2) {
-      throw new import_node_server_utils18.BadRequestError("Invalid supply ID format.");
-    }
-  }
-  return {
-    site: value.site,
-    supply: value.supply,
-    in: value.in ?? 0,
-    out: value.out ?? 0,
-    balance: value.balance,
-    remarks: value.remarks ?? "",
-    createdAt: (/* @__PURE__ */ new Date()).toISOString(),
-    status: "active",
-    updatedAt: "",
-    deletedAt: ""
-  };
-}
-
-// src/repositories/hygiene-stock.repository.ts
-var import_node_server_utils19 = require("@iservice365/node-server-utils");
-function useStockRepository() {
-  const db = import_node_server_utils19.useAtlas.getDb();
-  if (!db) {
-    throw new import_node_server_utils19.InternalServerError("Unable to connect to server.");
-  }
-  const namespace_collection = "site.supply.stocks";
-  const collection = db.collection(namespace_collection);
-  const { delNamespace } = (0, import_node_server_utils19.useCache)(namespace_collection);
-  async function createIndex() {
-    try {
-      await collection.createIndexes([
-        { key: { site: 1 } },
-        { key: { supply: 1 } },
-        { key: { balance: 1 } },
-        { key: { status: 1 } }
-      ]);
-    } catch (error) {
-      throw new import_node_server_utils19.InternalServerError("Failed to create index on hygiene stock.");
-    }
-  }
-  async function createStock(value, session) {
-    try {
-      value = MStock(value);
-      const res = await collection.insertOne(value, { session });
-      delNamespace().then(() => {
-        import_node_server_utils19.logger.info(`Cache cleared for namespace: ${namespace_collection}`);
-      }).catch((err) => {
-        import_node_server_utils19.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_utils19.BadRequestError("Stock already exists.");
-      }
-      throw error;
-    }
-  }
-  return {
-    createIndex,
-    createStock
-  };
-}
-
-// src/services/hygiene-supply.service.ts
-function useSupplyService() {
-  const { createSupply: _createSupply } = useSupplyRepository();
-  const { createStock } = useStockRepository();
-  async function createSupply(value) {
-    const session = import_node_server_utils20.useAtlas.getClient()?.startSession();
-    try {
-      session?.startTransaction();
-      const { qty, site } = value;
-      const supply = await _createSupply(value, session);
-      const createdSupply = await createStock(
-        {
-          site,
-          supply: supply.toString(),
-          in: qty,
-          balance: qty
-        },
-        session
-      );
-      await session?.commitTransaction();
-      return createdSupply;
-    } catch (error) {
-      await session?.abortTransaction();
-      throw error;
-    } finally {
-      await session?.endSession();
-    }
-  }
-  return { createSupply };
-}
-
-// src/controllers/hygiene-supply.controller.ts
-var import_node_server_utils21 = require("@iservice365/node-server-utils");
-var import_joi11 = __toESM(require("joi"));
 function useSupplyController() {
   const {
+    createSupply: _createSupply,
     getSupplies: _getSupplies,
     getSupplyById: _getSupplyById,
     updateSupply: _updateSupply,
     deleteSupply: _deleteSupply
   } = useSupplyRepository();
-  const { createSupply: _createSupply } = useSupplyService();
   async function createSupply(req, res, next) {
     const payload = { ...req.body, ...req.params };
     const { error } = supplySchema.validate(payload);
     if (error) {
-      import_node_server_utils21.logger.log({ level: "error", message: error.message });
-      next(new import_node_server_utils21.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 {
@@ -3241,27 +3133,27 @@ function useSupplyController() {
       res.status(201).json({ message: "Supply created successfully.", id });
       return;
     } catch (error2) {
-      import_node_server_utils21.logger.log({ level: "error", message: error2.message });
+      import_node_server_utils18.logger.log({ level: "error", message: error2.message });
       next(error2);
       return;
     }
   }
   async function getSupplies(req, res, next) {
     const query = { ...req.query, ...req.params };
-    const validation = import_joi11.default.object({
-      page: import_joi11.default.number().min(1).optional().allow("", null),
-      limit: import_joi11.default.number().min(1).optional().allow("", null),
-      search: import_joi11.default.string().optional().allow("", null),
-      site: import_joi11.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()
     });
     const { error } = validation.validate(query);
     if (error) {
-      import_node_server_utils21.logger.log({ level: "error", message: error.message });
-      next(new import_node_server_utils21.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 limit = parseInt(req.query.limit) ?? 10;
     const search = req.query.search ?? "";
     const site = req.params.site ?? "";
     try {
@@ -3274,18 +3166,18 @@ function useSupplyController() {
       res.json(data);
       return;
     } catch (error2) {
-      import_node_server_utils21.logger.log({ level: "error", message: error2.message });
+      import_node_server_utils18.logger.log({ level: "error", message: error2.message });
       next(error2);
       return;
     }
   }
   async function getSupplyById(req, res, next) {
-    const validation = import_joi11.default.string().hex().required();
+    const validation = import_joi10.default.string().hex().required();
     const _id = req.params.id;
     const { error } = validation.validate(_id);
     if (error) {
-      import_node_server_utils21.logger.log({ level: "error", message: error.message });
-      next(new import_node_server_utils21.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 {
@@ -3293,23 +3185,23 @@ function useSupplyController() {
       res.json(data);
       return;
     } catch (error2) {
-      import_node_server_utils21.logger.log({ level: "error", message: error2.message });
+      import_node_server_utils18.logger.log({ level: "error", message: error2.message });
       next(error2);
       return;
     }
   }
   async function updateSupply(req, res, next) {
     const payload = { id: req.params.id, ...req.body };
-    const validation = import_joi11.default.object({
-      id: import_joi11.default.string().hex().required(),
-      name: import_joi11.default.string().optional().allow("", null),
-      unitOfMeasurement: import_joi11.default.string().optional().allow("", null),
-      qty: import_joi11.default.number().min(0).optional().allow("", null)
+    const validation = import_joi10.default.object({
+      id: 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_utils21.logger.log({ level: "error", message: error.message });
-      next(new import_node_server_utils21.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 {
@@ -3318,20 +3210,20 @@ function useSupplyController() {
       res.json({ message: "Supply updated successfully." });
       return;
     } catch (error2) {
-      import_node_server_utils21.logger.log({ level: "error", message: error2.message });
+      import_node_server_utils18.logger.log({ level: "error", message: error2.message });
       next(error2);
       return;
     }
   }
   async function deleteSupply(req, res, next) {
     const id = req.params.id;
-    const validation = import_joi11.default.object({
-      id: import_joi11.default.string().hex().required()
+    const validation = import_joi10.default.object({
+      id: import_joi10.default.string().hex().required()
     });
     const { error } = validation.validate({ id });
     if (error) {
-      import_node_server_utils21.logger.log({ level: "error", message: error.message });
-      next(new import_node_server_utils21.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 {
@@ -3339,7 +3231,7 @@ function useSupplyController() {
       res.json({ message: "Supply deleted successfully." });
       return;
     } catch (error2) {
-      import_node_server_utils21.logger.log({ level: "error", message: error2.message });
+      import_node_server_utils18.logger.log({ level: "error", message: error2.message });
       next(error2);
       return;
     }
@@ -3353,24 +3245,203 @@ function useSupplyController() {
   };
 }
 
+// src/models/hygiene-stock.model.ts
+var import_node_server_utils19 = require("@iservice365/node-server-utils");
+var import_joi11 = __toESM(require("joi"));
+var import_mongodb11 = require("mongodb");
+var stockSchema = import_joi11.default.object({
+  site: import_joi11.default.string().hex().required(),
+  supply: import_joi11.default.string().hex().required(),
+  in: import_joi11.default.number().min(0).optional(),
+  out: import_joi11.default.number().min(0).optional(),
+  balance: import_joi11.default.number().min(0).required(),
+  remarks: import_joi11.default.string().optional().allow("", null)
+});
+function MStock(value) {
+  const { error } = stockSchema.validate(value);
+  if (error) {
+    import_node_server_utils19.logger.info(`Hygiene Stock Model: ${error.message}`);
+    throw new import_node_server_utils19.BadRequestError(error.message);
+  }
+  if (value.site) {
+    try {
+      value.site = new import_mongodb11.ObjectId(value.site);
+    } catch (error2) {
+      throw new import_node_server_utils19.BadRequestError("Invalid site ID format.");
+    }
+  }
+  if (value.supply) {
+    try {
+      value.supply = new import_mongodb11.ObjectId(value.supply);
+    } catch (error2) {
+      throw new import_node_server_utils19.BadRequestError("Invalid supply ID format.");
+    }
+  }
+  return {
+    site: value.site,
+    supply: value.supply,
+    in: value.in ?? 0,
+    out: value.out ?? 0,
+    balance: value.balance,
+    remarks: value.remarks ?? "",
+    createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+    status: "active",
+    updatedAt: "",
+    deletedAt: ""
+  };
+}
+
+// src/repositories/hygiene-stock.repository.ts
+var import_mongodb12 = require("mongodb");
+var import_node_server_utils20 = require("@iservice365/node-server-utils");
+function useStockRepository() {
+  const db = import_node_server_utils20.useAtlas.getDb();
+  if (!db) {
+    throw new import_node_server_utils20.InternalServerError("Unable to connect to server.");
+  }
+  const namespace_collection = "site.supply.stocks";
+  const supply_collection = "site.supplies";
+  const collection = db.collection(namespace_collection);
+  const { delNamespace, setCache, getCache } = (0, import_node_server_utils20.useCache)(namespace_collection);
+  const { delNamespace: delSupplyNamespace } = (0, import_node_server_utils20.useCache)(supply_collection);
+  async function createIndex() {
+    try {
+      await collection.createIndexes([
+        { key: { site: 1 } },
+        { key: { supply: 1 } },
+        { key: { balance: 1 } },
+        { key: { status: 1 } }
+      ]);
+    } catch (error) {
+      throw new import_node_server_utils20.InternalServerError("Failed to create index on hygiene stock.");
+    }
+  }
+  async function createStock(value, session) {
+    try {
+      value = MStock(value);
+      const res = await collection.insertOne(value, { session });
+      delNamespace().then(() => {
+        import_node_server_utils20.logger.info(`Cache cleared for namespace: ${namespace_collection}`);
+      }).catch((err) => {
+        import_node_server_utils20.logger.error(
+          `Failed to clear cache for namespace: ${namespace_collection}`,
+          err
+        );
+      });
+      delSupplyNamespace().then(() => {
+        import_node_server_utils20.logger.info(`Cache cleared for namespace: ${supply_collection}`);
+      }).catch((err) => {
+        import_node_server_utils20.logger.error(
+          `Failed to clear cache for namespace: ${supply_collection}`,
+          err
+        );
+      });
+      return res.insertedId;
+    } catch (error) {
+      throw error;
+    }
+  }
+  async function getStocksBySupplyId({
+    page = 1,
+    limit = 10,
+    search = "",
+    site,
+    supply
+  }) {
+    page = page > 0 ? page - 1 : 0;
+    const query = {
+      status: { $ne: "deleted" }
+    };
+    const cacheOptions = {
+      page,
+      limit
+    };
+    try {
+      site = new import_mongodb12.ObjectId(site);
+      query.site = site;
+      cacheOptions.site = site.toString();
+    } catch (error) {
+      throw new import_node_server_utils20.BadRequestError("Invalid site ID format.");
+    }
+    try {
+      supply = new import_mongodb12.ObjectId(supply);
+      query.supply = supply;
+      cacheOptions.supply = supply.toString();
+    } catch (error) {
+      throw new import_node_server_utils20.BadRequestError("Invalid supply ID format.");
+    }
+    if (search) {
+      query.$text = { $search: search };
+      cacheOptions.search = search;
+    }
+    const cacheKey = (0, import_node_server_utils20.makeCacheKey)(namespace_collection, cacheOptions);
+    const cachedData = await getCache(cacheKey);
+    if (cachedData) {
+      import_node_server_utils20.logger.info(`Cache hit for key: ${cacheKey}`);
+      return cachedData;
+    }
+    try {
+      const items = await collection.aggregate([
+        { $match: query },
+        {
+          $project: {
+            createdAt: 1,
+            in: 1,
+            out: 1,
+            balance: 1
+          }
+        },
+        { $sort: { _id: 1 } },
+        { $skip: page * limit },
+        { $limit: limit }
+      ]).toArray();
+      const length = await collection.countDocuments(query);
+      const data = (0, import_node_server_utils20.paginate)(items, page, limit, length);
+      setCache(cacheKey, data, 15 * 60).then(() => {
+        import_node_server_utils20.logger.info(`Cache set for key: ${cacheKey}`);
+      }).catch((err) => {
+        import_node_server_utils20.logger.error(`Failed to set cache for key: ${cacheKey}`, err);
+      });
+      return data;
+    } catch (error) {
+      throw error;
+    }
+  }
+  return {
+    createIndex,
+    createStock,
+    getStocksBySupplyId
+  };
+}
+
 // src/services/hygiene-stock.service.ts
-var import_node_server_utils22 = require("@iservice365/node-server-utils");
+var import_node_server_utils21 = require("@iservice365/node-server-utils");
 function useStockService() {
   const { createStock: _createStock } = useStockRepository();
   const { getSupplyById, updateSupply } = useSupplyRepository();
-  async function createStock(value) {
-    const session = import_node_server_utils22.useAtlas.getClient()?.startSession();
+  async function createStock(value, out = false) {
+    const session = import_node_server_utils21.useAtlas.getClient()?.startSession();
     try {
       session?.startTransaction();
       const { qty, ...stockData } = value;
-      const supply = await getSupplyById(value.supply);
+      const supply = await getSupplyById(value.supply, session);
       if (!supply || supply.qty === void 0) {
-        throw new import_node_server_utils22.NotFoundError("Supply not found.");
+        throw new import_node_server_utils21.NotFoundError("Supply not found.");
+      }
+      const newSupplyQty = out ? supply.qty - qty : supply.qty + qty;
+      if (out && newSupplyQty < 0) {
+        throw new import_node_server_utils21.BadRequestError(
+          `Insufficient stock. Available: ${supply.qty}, Requested: ${qty}`
+        );
       }
-      const newSupplyQty = supply.qty + qty;
       await updateSupply(value.supply, { qty: newSupplyQty }, session);
       const createdStock = await _createStock(
-        { ...stockData, in: qty, balance: newSupplyQty },
+        {
+          ...stockData,
+          in: out ? 0 : qty,
+          out: out ? qty : 0,
+          balance: newSupplyQty
+        },
         session
       );
       await session?.commitTransaction();
@@ -3386,22 +3457,23 @@ function useStockService() {
 }
 
 // src/controllers/hygiene-stock.controller.ts
-var import_node_server_utils23 = require("@iservice365/node-server-utils");
+var import_node_server_utils22 = require("@iservice365/node-server-utils");
 var import_joi12 = __toESM(require("joi"));
 function useStockController() {
+  const { getStocksBySupplyId: _getStocksBySupplyId } = useStockRepository();
   const { createStock: _createStock } = useStockService();
   async function createStock(req, res, next) {
     const payload = { ...req.body, ...req.params };
     const validation = import_joi12.default.object({
       site: import_joi12.default.string().hex().required(),
       supply: import_joi12.default.string().hex().required(),
-      qty: import_joi12.default.number().min(0).optional(),
+      qty: import_joi12.default.number().min(0).required(),
       remarks: import_joi12.default.string().optional().allow("", null)
     });
     const { error } = validation.validate(payload);
     if (error) {
-      import_node_server_utils23.logger.log({ level: "error", message: error.message });
-      next(new import_node_server_utils23.BadRequestError(error.message));
+      import_node_server_utils22.logger.log({ level: "error", message: error.message });
+      next(new import_node_server_utils22.BadRequestError(error.message));
       return;
     }
     try {
@@ -3409,13 +3481,1092 @@ function useStockController() {
       res.status(201).json({ message: "Stock created successfully.", id });
       return;
     } catch (error2) {
-      import_node_server_utils23.logger.log({ level: "error", message: error2.message });
+      import_node_server_utils22.logger.log({ level: "error", message: error2.message });
+      next(error2);
+      return;
+    }
+  }
+  async function getStocksBySupplyId(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(),
+      supply: import_joi12.default.string().hex().required()
+    });
+    const { error } = validation.validate(query);
+    if (error) {
+      import_node_server_utils22.logger.log({ level: "error", message: error.message });
+      next(new import_node_server_utils22.BadRequestError(error.message));
+      return;
+    }
+    const page = parseInt(req.query.page) ?? 1;
+    const limit = parseInt(req.query.limit) ?? 10;
+    const search = req.query.search ?? "";
+    const site = req.params.site ?? "";
+    const supply = req.params.supply ?? "";
+    try {
+      const data = await _getStocksBySupplyId({
+        page,
+        limit,
+        search,
+        site,
+        supply
+      });
+      res.json(data);
+      return;
+    } catch (error2) {
+      import_node_server_utils22.logger.log({ level: "error", message: error2.message });
+      next(error2);
+      return;
+    }
+  }
+  return {
+    createStock,
+    getStocksBySupplyId
+  };
+}
+
+// src/models/hygiene-request-item.model.ts
+var import_node_server_utils23 = require("@iservice365/node-server-utils");
+var import_joi13 = __toESM(require("joi"));
+var import_mongodb13 = require("mongodb");
+var allowedRequestItemStatus = [
+  "pending",
+  "approved",
+  "disapproved"
+];
+var requestItemSchema = import_joi13.default.object({
+  site: import_joi13.default.string().hex().required(),
+  supply: import_joi13.default.string().hex().required(),
+  supplyName: import_joi13.default.string().required(),
+  qty: import_joi13.default.number().min(0).required(),
+  createdBy: import_joi13.default.string().hex().required(),
+  createdByName: import_joi13.default.string().required()
+});
+function MRequestItem(value) {
+  const { error } = requestItemSchema.validate(value);
+  if (error) {
+    import_node_server_utils23.logger.info(`Hygiene Request Item Model: ${error.message}`);
+    throw new import_node_server_utils23.BadRequestError(error.message);
+  }
+  if (value.site) {
+    try {
+      value.site = new import_mongodb13.ObjectId(value.site);
+    } catch (error2) {
+      throw new import_node_server_utils23.BadRequestError("Invalid site ID format.");
+    }
+  }
+  if (value.supply) {
+    try {
+      value.supply = new import_mongodb13.ObjectId(value.supply);
+    } catch (error2) {
+      throw new import_node_server_utils23.BadRequestError("Invalid supply ID format.");
+    }
+  }
+  return {
+    site: value.site,
+    supply: value.supply,
+    supplyName: value.supplyName,
+    qty: value.qty,
+    remarks: "",
+    createdBy: value.createdBy,
+    createdByName: value.createdByName,
+    status: "pending",
+    createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+    updatedAt: "",
+    deletedAt: ""
+  };
+}
+
+// src/repositories/hygiene-request-item.repository.ts
+var import_mongodb14 = require("mongodb");
+var import_node_server_utils24 = require("@iservice365/node-server-utils");
+function useRequestItemRepository() {
+  const db = import_node_server_utils24.useAtlas.getDb();
+  if (!db) {
+    throw new import_node_server_utils24.InternalServerError("Unable to connect to server.");
+  }
+  const namespace_collection = "site.supply.requests";
+  const collection = db.collection(namespace_collection);
+  const { delNamespace, setCache, getCache } = (0, import_node_server_utils24.useCache)(namespace_collection);
+  async function createIndex() {
+    try {
+      await collection.createIndexes([
+        { key: { site: 1 } },
+        { key: { supply: 1 } },
+        { key: { status: 1 } }
+      ]);
+    } catch (error) {
+      throw new import_node_server_utils24.InternalServerError(
+        "Failed to create index on hygiene request item."
+      );
+    }
+  }
+  async function createTextIndex() {
+    try {
+      await collection.createIndex({ supplyName: "text" });
+    } catch (error) {
+      throw new import_node_server_utils24.InternalServerError(
+        "Failed to create text index on hygiene supply."
+      );
+    }
+  }
+  async function createRequestItem(value, session) {
+    try {
+      value = MRequestItem(value);
+      const res = await collection.insertOne(value, { session });
+      delNamespace().then(() => {
+        import_node_server_utils24.logger.info(`Cache cleared for namespace: ${namespace_collection}`);
+      }).catch((err) => {
+        import_node_server_utils24.logger.error(
+          `Failed to clear cache for namespace: ${namespace_collection}`,
+          err
+        );
+      });
+      return res.insertedId;
+    } catch (error) {
+      throw error;
+    }
+  }
+  async function getRequestItems({
+    page = 1,
+    limit = 10,
+    search = "",
+    site
+  }) {
+    page = page > 0 ? page - 1 : 0;
+    const query = {
+      status: { $ne: "deleted" }
+    };
+    const cacheOptions = {
+      page,
+      limit
+    };
+    try {
+      site = new import_mongodb14.ObjectId(site);
+      query.site = site;
+      cacheOptions.site = site.toString();
+    } catch (error) {
+      throw new import_node_server_utils24.BadRequestError("Invalid site ID format.");
+    }
+    if (search) {
+      query.$text = { $search: search };
+      cacheOptions.search = search;
+    }
+    const cacheKey = (0, import_node_server_utils24.makeCacheKey)(namespace_collection, cacheOptions);
+    const cachedData = await getCache(cacheKey);
+    if (cachedData) {
+      import_node_server_utils24.logger.info(`Cache hit for key: ${cacheKey}`);
+      return cachedData;
+    }
+    try {
+      const items = await collection.aggregate([
+        { $match: query },
+        {
+          $project: {
+            createdAt: 1,
+            status: 1
+          }
+        },
+        { $sort: { _id: -1 } },
+        { $skip: page * limit },
+        { $limit: limit }
+      ]).toArray();
+      const length = await collection.countDocuments(query);
+      const data = (0, import_node_server_utils24.paginate)(items, page, limit, length);
+      setCache(cacheKey, data, 15 * 60).then(() => {
+        import_node_server_utils24.logger.info(`Cache set for key: ${cacheKey}`);
+      }).catch((err) => {
+        import_node_server_utils24.logger.error(`Failed to set cache for key: ${cacheKey}`, err);
+      });
+      return data;
+    } catch (error) {
+      throw error;
+    }
+  }
+  async function getRequestItemById(_id, session) {
+    try {
+      _id = new import_mongodb14.ObjectId(_id);
+    } catch (error) {
+      throw new import_node_server_utils24.BadRequestError("Invalid request item ID format.");
+    }
+    const query = { _id };
+    const cacheKey = (0, import_node_server_utils24.makeCacheKey)(namespace_collection, {
+      _id: _id.toString()
+    });
+    if (!session) {
+      const cachedData = await getCache(cacheKey);
+      if (cachedData) {
+        import_node_server_utils24.logger.info(`Cache hit for key: ${cacheKey}`);
+        return cachedData;
+      }
+    } else {
+      import_node_server_utils24.logger.info(`Skipping cache during transaction for key: ${cacheKey}`);
+    }
+    try {
+      const data = await collection.aggregate([
+        { $match: query },
+        {
+          $lookup: {
+            from: "site.supply.items",
+            localField: "supply",
+            foreignField: "_id",
+            as: "supplyDetails"
+          }
+        },
+        {
+          $unwind: {
+            path: "$supplyDetails",
+            preserveNullAndEmptyArrays: true
+          }
+        },
+        {
+          $project: {
+            site: 1,
+            supply: 1,
+            supplyName: 1,
+            qty: 1,
+            status: 1,
+            unitOfMeasurement: "$supplyDetails.unitOfMeasurement"
+          }
+        }
+      ]).toArray();
+      if (!data || data.length === 0) {
+        throw new import_node_server_utils24.NotFoundError("Request item not found.");
+      }
+      setCache(cacheKey, data[0], 15 * 60).then(() => {
+        import_node_server_utils24.logger.info(`Cache set for key: ${cacheKey}`);
+      }).catch((err) => {
+        import_node_server_utils24.logger.error(`Failed to set cache for key: ${cacheKey}`, err);
+      });
+      return data[0];
+    } catch (error) {
+      throw error;
+    }
+  }
+  async function approveRequestItem(_id, remarks, session) {
+    try {
+      _id = new import_mongodb14.ObjectId(_id);
+    } catch (error) {
+      throw new import_node_server_utils24.BadRequestError("Invalid request item ID format.");
+    }
+    try {
+      const updateValue = {
+        status: "approved",
+        remarks: remarks || "",
+        updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+      };
+      const res = await collection.updateOne(
+        { _id },
+        { $set: updateValue },
+        { session }
+      );
+      if (res.modifiedCount === 0) {
+        throw new import_node_server_utils24.InternalServerError("Unable to approve request item.");
+      }
+      delNamespace().then(() => {
+        import_node_server_utils24.logger.info(`Cache cleared for namespace: ${namespace_collection}`);
+      }).catch((err) => {
+        import_node_server_utils24.logger.error(
+          `Failed to clear cache for namespace: ${namespace_collection}`,
+          err
+        );
+      });
+      return res.modifiedCount;
+    } catch (error) {
+      throw error;
+    }
+  }
+  async function disapproveRequestItem(_id, remarks, session) {
+    try {
+      _id = new import_mongodb14.ObjectId(_id);
+    } catch (error) {
+      throw new import_node_server_utils24.BadRequestError("Invalid request item ID format.");
+    }
+    try {
+      const updateValue = {
+        status: "disapproved",
+        remarks: remarks || "",
+        updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+      };
+      const res = await collection.updateOne(
+        { _id },
+        { $set: updateValue },
+        { session }
+      );
+      if (res.modifiedCount === 0) {
+        throw new import_node_server_utils24.InternalServerError("Unable to disapprove request item.");
+      }
+      delNamespace().then(() => {
+        import_node_server_utils24.logger.info(`Cache cleared for namespace: ${namespace_collection}`);
+      }).catch((err) => {
+        import_node_server_utils24.logger.error(
+          `Failed to clear cache for namespace: ${namespace_collection}`,
+          err
+        );
+      });
+      return res.modifiedCount;
+    } catch (error) {
+      throw error;
+    }
+  }
+  return {
+    createIndex,
+    createTextIndex,
+    createRequestItem,
+    getRequestItems,
+    getRequestItemById,
+    approveRequestItem,
+    disapproveRequestItem
+  };
+}
+
+// src/services/hygiene-request-item.service.ts
+var import_node_server_utils25 = require("@iservice365/node-server-utils");
+var import_core = require("@iservice365/core");
+function useRequestItemService() {
+  const {
+    createRequestItem: _createRequestItem,
+    getRequestItemById: _getRequestItemById,
+    approveRequestItem: _approveRequestItem,
+    disapproveRequestItem: _disapproveRequestItem
+  } = useRequestItemRepository();
+  const { getSupplyById } = useSupplyRepository();
+  const { getUserById } = (0, import_core.useUserRepo)();
+  const { createStock } = useStockService();
+  async function createRequestItem(value) {
+    try {
+      const { supply, createdBy } = value;
+      const supplyData = await getSupplyById(supply);
+      const createdByData = await getUserById(createdBy);
+      const createdRequestItem = await _createRequestItem({
+        ...value,
+        supplyName: supplyData?.name || "",
+        createdByName: createdByData?.name || ""
+      });
+      return createdRequestItem;
+    } catch (error) {
+      throw error;
+    }
+  }
+  async function createRequestItemByBatch(value) {
+    const session = import_node_server_utils25.useAtlas.getClient()?.startSession();
+    try {
+      session?.startTransaction();
+      const { site, createdBy, items } = value;
+      const createdByData = await getUserById(createdBy);
+      const createdRequestItemIds = [];
+      for (const item of items) {
+        const supplyData = await getSupplyById(item.supply, session);
+        const createdId = await _createRequestItem(
+          {
+            site,
+            supply: item.supply,
+            qty: item.qty,
+            supplyName: supplyData?.name || "",
+            createdBy,
+            createdByName: createdByData?.name || ""
+          },
+          session
+        );
+        createdRequestItemIds.push(createdId);
+      }
+      await session?.commitTransaction();
+      return createdRequestItemIds;
+    } catch (error) {
+      await session?.abortTransaction();
+      throw error;
+    } finally {
+      await session?.endSession();
+    }
+  }
+  async function approveRequestItem(id, remarks) {
+    const session = import_node_server_utils25.useAtlas.getClient()?.startSession();
+    try {
+      session?.startTransaction();
+      await _approveRequestItem(id, remarks, session);
+      const requestItem = await _getRequestItemById(id, session);
+      if (requestItem.status !== "pending") {
+        throw new import_node_server_utils25.BadRequestError(
+          "Only 'pending' request items can be approved."
+        );
+      }
+      const createdStocks = await createStock(
+        {
+          site: requestItem.site.toString(),
+          supply: requestItem.supply.toString(),
+          qty: requestItem.qty,
+          remarks
+        },
+        true
+      );
+      await session?.commitTransaction();
+      return createdStocks;
+    } catch (error) {
+      await session?.abortTransaction();
+      throw error;
+    } finally {
+      await session?.endSession();
+    }
+  }
+  async function disapproveRequestItem(id, remarks) {
+    const session = import_node_server_utils25.useAtlas.getClient()?.startSession();
+    try {
+      session?.startTransaction();
+      const result = await _disapproveRequestItem(id, remarks, session);
+      const requestItem = await _getRequestItemById(id, session);
+      if (requestItem.status !== "pending") {
+        throw new import_node_server_utils25.BadRequestError(
+          "Only 'pending' request items can be disapproved."
+        );
+      }
+      await session?.commitTransaction();
+      return result;
+    } catch (error) {
+      await session?.abortTransaction();
+      throw error;
+    } finally {
+      await session?.endSession();
+    }
+  }
+  return {
+    createRequestItem,
+    createRequestItemByBatch,
+    approveRequestItem,
+    disapproveRequestItem
+  };
+}
+
+// src/controllers/hygiene-request-item.controller.ts
+var import_node_server_utils26 = require("@iservice365/node-server-utils");
+var import_joi14 = __toESM(require("joi"));
+function useRequestItemController() {
+  const {
+    getRequestItems: _getRequestItems,
+    getRequestItemById: _getRequestItemById
+  } = useRequestItemRepository();
+  const {
+    createRequestItem: _createRequestItem,
+    createRequestItemByBatch: _createRequestItemByBatch,
+    approveRequestItem: _approveRequestItem,
+    disapproveRequestItem: _disapproveRequestItem
+  } = useRequestItemService();
+  async function createRequestItem(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_joi14.default.object({
+      site: import_joi14.default.string().hex().required(),
+      supply: import_joi14.default.string().hex().required(),
+      qty: import_joi14.default.number().min(0).required(),
+      createdBy: import_joi14.default.string().hex().required()
+    });
+    const { error } = validation.validate(payload);
+    if (error) {
+      import_node_server_utils26.logger.log({ level: "error", message: error.message });
+      next(new import_node_server_utils26.BadRequestError(error.message));
+      return;
+    }
+    try {
+      const id = await _createRequestItem(payload);
+      res.status(201).json({ message: "Request item created successfully.", id });
+      return;
+    } catch (error2) {
+      import_node_server_utils26.logger.log({ level: "error", message: error2.message });
+      next(error2);
+      return;
+    }
+  }
+  async function createRequestItemByBatch(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_joi14.default.object({
+      site: import_joi14.default.string().hex().required(),
+      createdBy: import_joi14.default.string().hex().required(),
+      items: import_joi14.default.array().items(
+        import_joi14.default.object({
+          supply: import_joi14.default.string().hex().required(),
+          qty: import_joi14.default.number().min(0).required()
+        })
+      ).min(1).required()
+    });
+    const { error } = validation.validate(payload);
+    if (error) {
+      import_node_server_utils26.logger.log({ level: "error", message: error.message });
+      next(new import_node_server_utils26.BadRequestError(error.message));
+      return;
+    }
+    try {
+      await _createRequestItemByBatch(payload);
+      res.status(201).json({ message: "Request items created successfully." });
+      return;
+    } catch (error2) {
+      import_node_server_utils26.logger.log({ level: "error", message: error2.message });
+      next(error2);
+      return;
+    }
+  }
+  async function getRequestItems(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()
+    });
+    const { error } = validation.validate(query);
+    if (error) {
+      import_node_server_utils26.logger.log({ level: "error", message: error.message });
+      next(new import_node_server_utils26.BadRequestError(error.message));
+      return;
+    }
+    const page = parseInt(req.query.page) ?? 1;
+    const limit = parseInt(req.query.limit) ?? 10;
+    const search = req.query.search ?? "";
+    const site = req.params.site ?? "";
+    try {
+      const data = await _getRequestItems({
+        page,
+        limit,
+        search,
+        site
+      });
+      res.json(data);
+      return;
+    } catch (error2) {
+      import_node_server_utils26.logger.log({ level: "error", message: error2.message });
+      next(error2);
+      return;
+    }
+  }
+  async function getRequestItemById(req, res, next) {
+    const validation = import_joi14.default.string().hex().required();
+    const _id = req.params.id;
+    const { error } = validation.validate(_id);
+    if (error) {
+      import_node_server_utils26.logger.log({ level: "error", message: error.message });
+      next(new import_node_server_utils26.BadRequestError(error.message));
+      return;
+    }
+    try {
+      const data = await _getRequestItemById(_id);
+      res.json(data);
+      return;
+    } catch (error2) {
+      import_node_server_utils26.logger.log({ level: "error", message: error2.message });
+      next(error2);
+      return;
+    }
+  }
+  async function approveRequestItem(req, res, next) {
+    const payload = { ...req.params, ...req.body };
+    const validation = import_joi14.default.object({
+      id: import_joi14.default.string().hex().required(),
+      remarks: import_joi14.default.string().optional().allow("", null)
+    });
+    const { error } = validation.validate(payload);
+    if (error) {
+      import_node_server_utils26.logger.log({ level: "error", message: error.message });
+      next(new import_node_server_utils26.BadRequestError(error.message));
+      return;
+    }
+    try {
+      await _approveRequestItem(payload.id, payload.remarks);
+      res.json({ message: "Request item approved successfully." });
+      return;
+    } catch (error2) {
+      import_node_server_utils26.logger.log({ level: "error", message: error2.message });
+      next(error2);
+      return;
+    }
+  }
+  async function disapproveRequestItem(req, res, next) {
+    const payload = { ...req.params, ...req.body };
+    const validation = import_joi14.default.object({
+      id: import_joi14.default.string().hex().required(),
+      remarks: import_joi14.default.string().optional().allow("", null)
+    });
+    const { error } = validation.validate(payload);
+    if (error) {
+      import_node_server_utils26.logger.log({ level: "error", message: error.message });
+      next(new import_node_server_utils26.BadRequestError(error.message));
+      return;
+    }
+    try {
+      await _disapproveRequestItem(payload.id, payload.remarks);
+      res.json({ message: "Request item disapproved successfully." });
+      return;
+    } catch (error2) {
+      import_node_server_utils26.logger.log({ level: "error", message: error2.message });
+      next(error2);
+      return;
+    }
+  }
+  return {
+    createRequestItem,
+    createRequestItemByBatch,
+    getRequestItems,
+    getRequestItemById,
+    approveRequestItem,
+    disapproveRequestItem
+  };
+}
+
+// src/models/hygiene-schedule-task.model.ts
+var import_node_server_utils27 = require("@iservice365/node-server-utils");
+var import_joi15 = __toESM(require("joi"));
+var import_mongodb15 = require("mongodb");
+var allowedFrequency = ["week", "month", "quarter", "year"];
+var allowedDays = [
+  "Mon",
+  "Tue",
+  "Wed",
+  "Thu",
+  "Fri",
+  "Sat",
+  "Sun"
+];
+var allowedQuarter = ["1st", "2nd", "3rd", "4th"];
+var allowedWeekOfMonth = [
+  "1st",
+  "2nd",
+  "3rd",
+  "4th",
+  "last"
+];
+var allowedMonths = [
+  "January",
+  "February",
+  "March",
+  "April",
+  "May",
+  "June",
+  "July",
+  "August",
+  "September",
+  "October",
+  "November",
+  "December"
+];
+var scheduleTaskSchema = import_joi15.default.object({
+  site: import_joi15.default.string().hex().required(),
+  title: import_joi15.default.string().required(),
+  frequency: import_joi15.default.string().valid(...allowedFrequency).required(),
+  day: import_joi15.default.string().valid(...allowedDays).required(),
+  weekOfMonth: import_joi15.default.string().valid(...allowedWeekOfMonth).when("frequency", {
+    is: import_joi15.default.string().valid("month", "quarter", "year"),
+    then: import_joi15.default.required(),
+    otherwise: import_joi15.default.optional().allow("", null)
+  }),
+  quarter: import_joi15.default.string().valid(...allowedQuarter).when("frequency", {
+    is: "quarter",
+    then: import_joi15.default.required(),
+    otherwise: import_joi15.default.optional().allow("", null)
+  }),
+  month: import_joi15.default.string().valid(...allowedMonths).when("frequency", {
+    is: import_joi15.default.string().valid("quarter", "year"),
+    then: import_joi15.default.required(),
+    otherwise: import_joi15.default.optional().allow("", null)
+  }),
+  description: import_joi15.default.string().optional().allow("", null),
+  areas: import_joi15.default.array().min(1).items(
+    import_joi15.default.object({
+      name: import_joi15.default.string().required(),
+      value: import_joi15.default.any().required()
+    })
+  ).required()
+});
+function MScheduleTask(value) {
+  const { error } = scheduleTaskSchema.validate(value);
+  if (error) {
+    import_node_server_utils27.logger.info(`Hygiene Schedule Task Model: ${error.message}`);
+    throw new import_node_server_utils27.BadRequestError(error.message);
+  }
+  if (value.site) {
+    try {
+      value.site = new import_mongodb15.ObjectId(value.site);
+    } catch (error2) {
+      throw new import_node_server_utils27.BadRequestError("Invalid site ID format.");
+    }
+  }
+  if (value.areas && Array.isArray(value.areas)) {
+    value.areas = value.areas.map((area) => {
+      try {
+        return {
+          name: area.name,
+          value: new import_mongodb15.ObjectId(area.value.toString())
+        };
+      } catch (error2) {
+        throw new import_node_server_utils27.BadRequestError(`Invalid area value format: ${area.name}`);
+      }
+    });
+  }
+  return {
+    site: value.site,
+    title: value.title,
+    frequency: value.frequency,
+    day: value.day,
+    weekOfMonth: value.weekOfMonth,
+    quarter: value.quarter,
+    month: value.month,
+    description: value.description,
+    areas: value.areas,
+    status: "active",
+    createdAt: /* @__PURE__ */ new Date(),
+    updatedAt: "",
+    deletedAt: ""
+  };
+}
+
+// src/repositories/hygiene-schedule-task.repository.ts
+var import_mongodb16 = require("mongodb");
+var import_node_server_utils28 = require("@iservice365/node-server-utils");
+function useScheduleTaskRepository() {
+  const db = import_node_server_utils28.useAtlas.getDb();
+  if (!db) {
+    throw new import_node_server_utils28.InternalServerError("Unable to connect to server.");
+  }
+  const namespace_collection = "site.schedule-tasks";
+  const collection = db.collection(namespace_collection);
+  const { delNamespace, setCache, getCache } = (0, import_node_server_utils28.useCache)(namespace_collection);
+  async function createIndex() {
+    try {
+      await collection.createIndexes([
+        { key: { site: 1 } },
+        { key: { status: 1 } }
+      ]);
+    } catch (error) {
+      throw new import_node_server_utils28.InternalServerError(
+        "Failed to create index on hygiene schedule task."
+      );
+    }
+  }
+  async function createTextIndex() {
+    try {
+      await collection.createIndex({ title: "text", description: "text" });
+    } catch (error) {
+      throw new import_node_server_utils28.InternalServerError(
+        "Failed to create text index on hygiene schedule task."
+      );
+    }
+  }
+  async function createScheduleTask(value, session) {
+    try {
+      value = MScheduleTask(value);
+      const res = await collection.insertOne(value, { session });
+      delNamespace().then(() => {
+        import_node_server_utils28.logger.info(`Cache cleared for namespace: ${namespace_collection}`);
+      }).catch((err) => {
+        import_node_server_utils28.logger.error(
+          `Failed to clear cache for namespace: ${namespace_collection}`,
+          err
+        );
+      });
+      return res.insertedId;
+    } catch (error) {
+      throw error;
+    }
+  }
+  async function getScheduleTasks({
+    page = 1,
+    limit = 10,
+    search = "",
+    site
+  }) {
+    page = page > 0 ? page - 1 : 0;
+    const query = {
+      status: { $ne: "deleted" }
+    };
+    const cacheOptions = {
+      page,
+      limit
+    };
+    try {
+      site = new import_mongodb16.ObjectId(site);
+      query.site = site;
+      cacheOptions.site = site.toString();
+    } catch (error) {
+      throw new import_node_server_utils28.BadRequestError("Invalid site ID format.");
+    }
+    if (search) {
+      query.$or = [{ name: { $regex: search, $options: "i" } }];
+      cacheOptions.search = search;
+    }
+    const cacheKey = (0, import_node_server_utils28.makeCacheKey)(namespace_collection, cacheOptions);
+    const cachedData = await getCache(cacheKey);
+    if (cachedData) {
+      import_node_server_utils28.logger.info(`Cache hit for key: ${cacheKey}`);
+      return cachedData;
+    }
+    try {
+      const items = await collection.aggregate([
+        { $match: query },
+        {
+          $project: {
+            title: 1,
+            areas: 1,
+            status: 1
+          }
+        },
+        { $sort: { _id: -1 } },
+        { $skip: page * limit },
+        { $limit: limit }
+      ]).toArray();
+      const length = await collection.countDocuments(query);
+      const data = (0, import_node_server_utils28.paginate)(items, page, limit, length);
+      setCache(cacheKey, data, 15 * 60).then(() => {
+        import_node_server_utils28.logger.info(`Cache set for key: ${cacheKey}`);
+      }).catch((err) => {
+        import_node_server_utils28.logger.error(`Failed to set cache for key: ${cacheKey}`, err);
+      });
+      return data;
+    } catch (error) {
+      throw error;
+    }
+  }
+  async function getScheduleTaskById(_id, session) {
+    try {
+      _id = new import_mongodb16.ObjectId(_id);
+    } catch (error) {
+      throw new import_node_server_utils28.BadRequestError("Invalid schedule task ID format.");
+    }
+    const query = {
+      _id,
+      status: { $ne: "deleted" }
+    };
+    const cacheKey = (0, import_node_server_utils28.makeCacheKey)(namespace_collection, {
+      _id: _id.toString()
+    });
+    if (!session) {
+      const cachedData = await getCache(cacheKey);
+      if (cachedData) {
+        import_node_server_utils28.logger.info(`Cache hit for key: ${cacheKey}`);
+        return cachedData;
+      }
+    } else {
+      import_node_server_utils28.logger.info(`Skipping cache during transaction for key: ${cacheKey}`);
+    }
+    try {
+      const data = await collection.aggregate([
+        { $match: query },
+        {
+          $project: {
+            title: 1,
+            frequency: 1,
+            day: 1,
+            weekOfMonth: 1,
+            quarter: 1,
+            month: 1,
+            description: 1,
+            areas: 1,
+            status: 1,
+            createdAt: 1
+          }
+        }
+      ]).toArray();
+      if (!data || data.length === 0) {
+        throw new import_node_server_utils28.NotFoundError("Schedule task not found.");
+      }
+      setCache(cacheKey, data[0], 15 * 60).then(() => {
+        import_node_server_utils28.logger.info(`Cache set for key: ${cacheKey}`);
+      }).catch((err) => {
+        import_node_server_utils28.logger.error(`Failed to set cache for key: ${cacheKey}`, err);
+      });
+      return data[0];
+    } catch (error) {
+      throw error;
+    }
+  }
+  async function updateScheduleTask(_id, value, session) {
+    try {
+      _id = new import_mongodb16.ObjectId(_id);
+    } catch (error) {
+      throw new import_node_server_utils28.BadRequestError("Invalid schedule task ID format.");
+    }
+    if (value.areas && Array.isArray(value.areas)) {
+      value.areas = value.areas.map((area) => {
+        try {
+          return {
+            name: area.name,
+            value: new import_mongodb16.ObjectId(area.value.toString())
+          };
+        } catch (error) {
+          throw new import_node_server_utils28.BadRequestError(`Invalid area value format: ${area.name}`);
+        }
+      });
+    }
+    try {
+      const updateValue = { ...value, updatedAt: /* @__PURE__ */ new Date() };
+      const res = await collection.updateOne(
+        { _id },
+        { $set: updateValue },
+        { session }
+      );
+      if (res.modifiedCount === 0) {
+        throw new import_node_server_utils28.InternalServerError(
+          "Unable to update hygiene schedule task."
+        );
+      }
+      delNamespace().then(() => {
+        import_node_server_utils28.logger.info(`Cache cleared for namespace: ${namespace_collection}`);
+      }).catch((err) => {
+        import_node_server_utils28.logger.error(
+          `Failed to clear cache for namespace: ${namespace_collection}`,
+          err
+        );
+      });
+      return res.modifiedCount;
+    } catch (error) {
+      throw error;
+    }
+  }
+  return {
+    createIndex,
+    createTextIndex,
+    createScheduleTask,
+    getScheduleTasks,
+    getScheduleTaskById,
+    updateScheduleTask
+  };
+}
+
+// src/controllers/hygiene-schedule-task.controller.ts
+var import_node_server_utils29 = require("@iservice365/node-server-utils");
+var import_joi16 = __toESM(require("joi"));
+function useScheduleTaskController() {
+  const {
+    createScheduleTask: _createScheduleTask,
+    getScheduleTasks: _getScheduleTasks,
+    getScheduleTaskById: _getScheduleTaskById,
+    updateScheduleTask: _updateScheduleTask
+  } = useScheduleTaskRepository();
+  async function createScheduleTask(req, res, next) {
+    const payload = { ...req.body, ...req.params };
+    const { error } = scheduleTaskSchema.validate(payload);
+    if (error) {
+      import_node_server_utils29.logger.log({ level: "error", message: error.message });
+      next(new import_node_server_utils29.BadRequestError(error.message));
+      return;
+    }
+    try {
+      const id = await _createScheduleTask(payload);
+      res.status(201).json({ message: "Schedule task created successfully.", id });
+      return;
+    } catch (error2) {
+      import_node_server_utils29.logger.log({ level: "error", message: error2.message });
+      next(error2);
+      return;
+    }
+  }
+  async function getScheduleTasks(req, res, next) {
+    const query = { ...req.query, ...req.params };
+    const validation = import_joi16.default.object({
+      page: import_joi16.default.number().min(1).optional().allow("", null),
+      limit: import_joi16.default.number().min(1).optional().allow("", null),
+      search: import_joi16.default.string().optional().allow("", null),
+      site: import_joi16.default.string().hex().required()
+    });
+    const { error } = validation.validate(query);
+    if (error) {
+      import_node_server_utils29.logger.log({ level: "error", message: error.message });
+      next(new import_node_server_utils29.BadRequestError(error.message));
+      return;
+    }
+    const page = parseInt(req.query.page) ?? 1;
+    const limit = parseInt(req.query.limit) ?? 10;
+    const search = req.query.search ?? "";
+    const site = req.params.site ?? "";
+    try {
+      const data = await _getScheduleTasks({
+        page,
+        limit,
+        search,
+        site
+      });
+      res.json(data);
+      return;
+    } catch (error2) {
+      import_node_server_utils29.logger.log({ level: "error", message: error2.message });
+      next(error2);
+      return;
+    }
+  }
+  async function getScheduleTaskById(req, res, next) {
+    const validation = import_joi16.default.string().hex().required();
+    const _id = req.params.id;
+    const { error } = validation.validate(_id);
+    if (error) {
+      import_node_server_utils29.logger.log({ level: "error", message: error.message });
+      next(new import_node_server_utils29.BadRequestError(error.message));
+      return;
+    }
+    try {
+      const data = await _getScheduleTaskById(_id);
+      res.json(data);
+      return;
+    } catch (error2) {
+      import_node_server_utils29.logger.log({ level: "error", message: error2.message });
+      next(error2);
+      return;
+    }
+  }
+  async function updateScheduleTask(req, res, next) {
+    const payload = { id: req.params.id, ...req.body };
+    const validation = import_joi16.default.object({
+      id: import_joi16.default.string().hex().required(),
+      title: import_joi16.default.string().optional().allow("", null),
+      frequency: import_joi16.default.string().valid(...allowedFrequency).optional().allow("", null),
+      day: import_joi16.default.string().valid(...allowedDays).optional().allow("", null),
+      weekOfMonth: import_joi16.default.string().valid(...allowedWeekOfMonth).optional().allow("", null),
+      quarter: import_joi16.default.string().valid(...allowedQuarter).optional().allow("", null),
+      month: import_joi16.default.string().valid(...allowedMonths).optional().allow("", null),
+      description: import_joi16.default.string().optional().allow("", null),
+      areas: import_joi16.default.array().min(1).items(
+        import_joi16.default.object({
+          name: import_joi16.default.string().required(),
+          value: import_joi16.default.any().required()
+        })
+      ).optional()
+    });
+    const { error } = validation.validate(payload);
+    if (error) {
+      import_node_server_utils29.logger.log({ level: "error", message: error.message });
+      next(new import_node_server_utils29.BadRequestError(error.message));
+      return;
+    }
+    try {
+      const { id, ...value } = payload;
+      await _updateScheduleTask(id, value);
+      res.json({ message: "Schedule task updated successfully." });
+      return;
+    } catch (error2) {
+      import_node_server_utils29.logger.log({ level: "error", message: error2.message });
       next(error2);
       return;
     }
   }
   return {
-    createStock
+    createScheduleTask,
+    getScheduleTasks,
+    getScheduleTaskById,
+    updateScheduleTask
   };
 }
 // Annotate the CommonJS export names for ESM import in node:
@@ -3423,15 +4574,25 @@ function useStockController() {
   MArea,
   MAreaChecklist,
   MParentChecklist,
+  MRequestItem,
+  MScheduleTask,
   MStock,
   MSupply,
   MUnit,
   allowedChecklistStatus,
+  allowedDays,
+  allowedFrequency,
+  allowedMonths,
+  allowedQuarter,
+  allowedRequestItemStatus,
   allowedStatus,
   allowedTypes,
+  allowedWeekOfMonth,
   areaChecklistSchema,
   areaSchema,
   parentChecklistSchema,
+  requestItemSchema,
+  scheduleTaskSchema,
   stockSchema,
   supplySchema,
   unitSchema,
@@ -3443,12 +4604,16 @@ function useStockController() {
   useAreaService,
   useParentChecklistController,
   useParentChecklistRepo,
+  useRequestItemController,
+  useRequestItemRepository,
+  useRequestItemService,
+  useScheduleTaskController,
+  useScheduleTaskRepository,
   useStockController,
   useStockRepository,
   useStockService,
   useSupplyController,
   useSupplyRepository,
-  useSupplyService,
   useUnitController,
   useUnitRepository,
   useUnitService