@iservice365/module-hygiene 1.1.0 → 1.4.0

package/dist/index.mjs

@@ -790,8 +790,8 @@ function MUnit(value) {
   return {
     site: value.site,
     name: value.name,
-    createdAt: /* @__PURE__ */ new Date(),
     status: "active",
+    createdAt: /* @__PURE__ */ new Date(),
     updatedAt: "",
     deletedAt: ""
   };
@@ -1503,6 +1503,9 @@ function useParentChecklistRepo() {
         status,
         updatedAt: /* @__PURE__ */ new Date()
       };
+      if (status === "completed") {
+        updateValue.completedAt = /* @__PURE__ */ new Date();
+      }
       const res = await collection.updateOne(
         { _id },
         { $set: updateValue },
@@ -2932,7 +2935,8 @@ function useSupplyRepository() {
         {
           $project: {
             name: 1,
-            qty: 1
+            qty: 1,
+            status: 1
           }
         },
         { $sort: { _id: -1 } },
@@ -3025,7 +3029,7 @@ function useSupplyRepository() {
     } catch (error) {
       const isDuplicated = error.message.includes("duplicate");
       if (isDuplicated) {
-        throw new BadRequestError16("Area already exists.");
+        throw new BadRequestError16("Supply already exists.");
       }
       throw error;
     }
@@ -3567,7 +3571,8 @@ import {
   logger as logger23,
   makeCacheKey as makeCacheKey7,
   paginate as paginate7,
-  BadRequestError as BadRequestError23
+  BadRequestError as BadRequestError23,
+  NotFoundError as NotFoundError6
 } from "@iservice365/node-server-utils";
 function useRequestItemRepository() {
   const db = useAtlas10.getDb();
@@ -3656,7 +3661,7 @@ function useRequestItemRepository() {
             status: 1
           }
         },
-        { $sort: { _id: 1 } },
+        { $sort: { _id: -1 } },
         { $skip: page * limit },
         { $limit: limit }
       ]).toArray();
@@ -3672,21 +3677,156 @@ function useRequestItemRepository() {
       throw error;
     }
   }
+  async function getRequestItemById(_id, session) {
+    try {
+      _id = new ObjectId14(_id);
+    } catch (error) {
+      throw new BadRequestError23("Invalid request item ID format.");
+    }
+    const query = { _id };
+    const cacheKey = makeCacheKey7(namespace_collection, {
+      _id: _id.toString()
+    });
+    if (!session) {
+      const cachedData = await getCache(cacheKey);
+      if (cachedData) {
+        logger23.info(`Cache hit for key: ${cacheKey}`);
+        return cachedData;
+      }
+    } else {
+      logger23.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 NotFoundError6("Request item not found.");
+      }
+      setCache(cacheKey, data[0], 15 * 60).then(() => {
+        logger23.info(`Cache set for key: ${cacheKey}`);
+      }).catch((err) => {
+        logger23.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 ObjectId14(_id);
+    } catch (error) {
+      throw new BadRequestError23("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 InternalServerError7("Unable to approve request item.");
+      }
+      delNamespace().then(() => {
+        logger23.info(`Cache cleared for namespace: ${namespace_collection}`);
+      }).catch((err) => {
+        logger23.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 ObjectId14(_id);
+    } catch (error) {
+      throw new BadRequestError23("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 InternalServerError7("Unable to disapprove request item.");
+      }
+      delNamespace().then(() => {
+        logger23.info(`Cache cleared for namespace: ${namespace_collection}`);
+      }).catch((err) => {
+        logger23.error(
+          `Failed to clear cache for namespace: ${namespace_collection}`,
+          err
+        );
+      });
+      return res.modifiedCount;
+    } catch (error) {
+      throw error;
+    }
+  }
   return {
     createIndex,
     createTextIndex,
     createRequestItem,
-    getRequestItems
+    getRequestItems,
+    getRequestItemById,
+    approveRequestItem,
+    disapproveRequestItem
   };
 }
 
 // src/services/hygiene-request-item.service.ts
-import { useAtlas as useAtlas11 } from "@iservice365/node-server-utils";
+import { BadRequestError as BadRequestError24, useAtlas as useAtlas11 } from "@iservice365/node-server-utils";
 import { useUserRepo } from "@iservice365/core";
 function useRequestItemService() {
-  const { createRequestItem: _createRequestItem } = useRequestItemRepository();
+  const {
+    createRequestItem: _createRequestItem,
+    getRequestItemById: _getRequestItemById,
+    approveRequestItem: _approveRequestItem,
+    disapproveRequestItem: _disapproveRequestItem
+  } = useRequestItemRepository();
   const { getSupplyById } = useSupplyRepository();
   const { getUserById } = useUserRepo();
+  const { createStock } = useStockService();
   async function createRequestItem(value) {
     try {
       const { supply, createdBy } = value;
@@ -3733,17 +3873,76 @@ function useRequestItemService() {
       await session?.endSession();
     }
   }
-  return { createRequestItem, createRequestItemByBatch };
+  async function approveRequestItem(id, remarks) {
+    const session = useAtlas11.getClient()?.startSession();
+    try {
+      session?.startTransaction();
+      await _approveRequestItem(id, remarks, session);
+      const requestItem = await _getRequestItemById(id, session);
+      if (requestItem.status !== "pending") {
+        throw new BadRequestError24(
+          "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 = useAtlas11.getClient()?.startSession();
+    try {
+      session?.startTransaction();
+      const result = await _disapproveRequestItem(id, remarks, session);
+      const requestItem = await _getRequestItemById(id, session);
+      if (requestItem.status !== "pending") {
+        throw new BadRequestError24(
+          "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
-import { BadRequestError as BadRequestError24, logger as logger24 } from "@iservice365/node-server-utils";
+import { BadRequestError as BadRequestError25, logger as logger24 } from "@iservice365/node-server-utils";
 import Joi14 from "joi";
 function useRequestItemController() {
-  const { getRequestItems: _getRequestItems } = useRequestItemRepository();
+  const {
+    getRequestItems: _getRequestItems,
+    getRequestItemById: _getRequestItemById
+  } = useRequestItemRepository();
   const {
     createRequestItem: _createRequestItem,
-    createRequestItemByBatch: _createRequestItemByBatch
+    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(
@@ -3765,7 +3964,7 @@ function useRequestItemController() {
     const { error } = validation.validate(payload);
     if (error) {
       logger24.log({ level: "error", message: error.message });
-      next(new BadRequestError24(error.message));
+      next(new BadRequestError25(error.message));
       return;
     }
     try {
@@ -3802,7 +4001,7 @@ function useRequestItemController() {
     const { error } = validation.validate(payload);
     if (error) {
       logger24.log({ level: "error", message: error.message });
-      next(new BadRequestError24(error.message));
+      next(new BadRequestError25(error.message));
       return;
     }
     try {
@@ -3826,7 +4025,7 @@ function useRequestItemController() {
     const { error } = validation.validate(query);
     if (error) {
       logger24.log({ level: "error", message: error.message });
-      next(new BadRequestError24(error.message));
+      next(new BadRequestError25(error.message));
       return;
     }
     const page = parseInt(req.query.page) ?? 1;
@@ -3848,10 +4047,530 @@ function useRequestItemController() {
       return;
     }
   }
+  async function getRequestItemById(req, res, next) {
+    const validation = Joi14.string().hex().required();
+    const _id = req.params.id;
+    const { error } = validation.validate(_id);
+    if (error) {
+      logger24.log({ level: "error", message: error.message });
+      next(new BadRequestError25(error.message));
+      return;
+    }
+    try {
+      const data = await _getRequestItemById(_id);
+      res.json(data);
+      return;
+    } catch (error2) {
+      logger24.log({ level: "error", message: error2.message });
+      next(error2);
+      return;
+    }
+  }
+  async function approveRequestItem(req, res, next) {
+    const payload = { ...req.params, ...req.body };
+    const validation = Joi14.object({
+      id: Joi14.string().hex().required(),
+      remarks: Joi14.string().optional().allow("", null)
+    });
+    const { error } = validation.validate(payload);
+    if (error) {
+      logger24.log({ level: "error", message: error.message });
+      next(new BadRequestError25(error.message));
+      return;
+    }
+    try {
+      await _approveRequestItem(payload.id, payload.remarks);
+      res.json({ message: "Request item approved successfully." });
+      return;
+    } catch (error2) {
+      logger24.log({ level: "error", message: error2.message });
+      next(error2);
+      return;
+    }
+  }
+  async function disapproveRequestItem(req, res, next) {
+    const payload = { ...req.params, ...req.body };
+    const validation = Joi14.object({
+      id: Joi14.string().hex().required(),
+      remarks: Joi14.string().optional().allow("", null)
+    });
+    const { error } = validation.validate(payload);
+    if (error) {
+      logger24.log({ level: "error", message: error.message });
+      next(new BadRequestError25(error.message));
+      return;
+    }
+    try {
+      await _disapproveRequestItem(payload.id, payload.remarks);
+      res.json({ message: "Request item disapproved successfully." });
+      return;
+    } catch (error2) {
+      logger24.log({ level: "error", message: error2.message });
+      next(error2);
+      return;
+    }
+  }
   return {
     createRequestItem,
     createRequestItemByBatch,
-    getRequestItems
+    getRequestItems,
+    getRequestItemById,
+    approveRequestItem,
+    disapproveRequestItem
+  };
+}
+
+// src/models/hygiene-schedule-task.model.ts
+import { BadRequestError as BadRequestError26, logger as logger25 } from "@iservice365/node-server-utils";
+import Joi15 from "joi";
+import { ObjectId as ObjectId15 } from "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 = Joi15.object({
+  site: Joi15.string().hex().required(),
+  title: Joi15.string().required(),
+  frequency: Joi15.string().valid(...allowedFrequency).required(),
+  time: Joi15.string().pattern(/^([0-1]\d|2[0-3]):([0-5]\d)$/).required(),
+  day: Joi15.string().valid(...allowedDays).required(),
+  weekOfMonth: Joi15.string().valid(...allowedWeekOfMonth).when("frequency", {
+    is: Joi15.string().valid("month", "quarter", "year"),
+    then: Joi15.required(),
+    otherwise: Joi15.optional().allow("", null)
+  }),
+  quarter: Joi15.string().valid(...allowedQuarter).when("frequency", {
+    is: "quarter",
+    then: Joi15.required(),
+    otherwise: Joi15.optional().allow("", null)
+  }),
+  month: Joi15.string().valid(...allowedMonths).when("frequency", {
+    is: Joi15.string().valid("quarter", "year"),
+    then: Joi15.required(),
+    otherwise: Joi15.optional().allow("", null)
+  }),
+  description: Joi15.string().optional().allow("", null),
+  areas: Joi15.array().min(1).items(
+    Joi15.object({
+      name: Joi15.string().required(),
+      value: Joi15.any().required()
+    })
+  ).required()
+});
+function MScheduleTask(value) {
+  const { error } = scheduleTaskSchema.validate(value);
+  if (error) {
+    logger25.info(`Hygiene Schedule Task Model: ${error.message}`);
+    throw new BadRequestError26(error.message);
+  }
+  if (value.site) {
+    try {
+      value.site = new ObjectId15(value.site);
+    } catch (error2) {
+      throw new BadRequestError26("Invalid site ID format.");
+    }
+  }
+  if (value.areas && Array.isArray(value.areas)) {
+    value.areas = value.areas.map((area) => {
+      try {
+        return {
+          name: area.name,
+          value: new ObjectId15(area.value.toString())
+        };
+      } catch (error2) {
+        throw new BadRequestError26(`Invalid area value format: ${area.name}`);
+      }
+    });
+  }
+  return {
+    site: value.site,
+    title: value.title,
+    frequency: value.frequency,
+    time: value.time,
+    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
+import { ObjectId as ObjectId16 } from "mongodb";
+import {
+  useAtlas as useAtlas12,
+  InternalServerError as InternalServerError8,
+  paginate as paginate8,
+  BadRequestError as BadRequestError27,
+  useCache as useCache8,
+  logger as logger26,
+  makeCacheKey as makeCacheKey8,
+  NotFoundError as NotFoundError7
+} from "@iservice365/node-server-utils";
+function useScheduleTaskRepository() {
+  const db = useAtlas12.getDb();
+  if (!db) {
+    throw new InternalServerError8("Unable to connect to server.");
+  }
+  const namespace_collection = "site.schedule-tasks";
+  const collection = db.collection(namespace_collection);
+  const { delNamespace, setCache, getCache } = useCache8(namespace_collection);
+  async function createIndex() {
+    try {
+      await collection.createIndexes([
+        { key: { site: 1 } },
+        { key: { status: 1 } }
+      ]);
+    } catch (error) {
+      throw new InternalServerError8(
+        "Failed to create index on hygiene schedule task."
+      );
+    }
+  }
+  async function createTextIndex() {
+    try {
+      await collection.createIndex({ title: "text", description: "text" });
+    } catch (error) {
+      throw new InternalServerError8(
+        "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(() => {
+        logger26.info(`Cache cleared for namespace: ${namespace_collection}`);
+      }).catch((err) => {
+        logger26.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 ObjectId16(site);
+      query.site = site;
+      cacheOptions.site = site.toString();
+    } catch (error) {
+      throw new BadRequestError27("Invalid site ID format.");
+    }
+    if (search) {
+      query.$or = [{ name: { $regex: search, $options: "i" } }];
+      cacheOptions.search = search;
+    }
+    const cacheKey = makeCacheKey8(namespace_collection, cacheOptions);
+    const cachedData = await getCache(cacheKey);
+    if (cachedData) {
+      logger26.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 = paginate8(items, page, limit, length);
+      setCache(cacheKey, data, 15 * 60).then(() => {
+        logger26.info(`Cache set for key: ${cacheKey}`);
+      }).catch((err) => {
+        logger26.error(`Failed to set cache for key: ${cacheKey}`, err);
+      });
+      return data;
+    } catch (error) {
+      throw error;
+    }
+  }
+  async function getScheduleTaskById(_id, session) {
+    try {
+      _id = new ObjectId16(_id);
+    } catch (error) {
+      throw new BadRequestError27("Invalid schedule task ID format.");
+    }
+    const query = {
+      _id,
+      status: { $ne: "deleted" }
+    };
+    const cacheKey = makeCacheKey8(namespace_collection, {
+      _id: _id.toString()
+    });
+    if (!session) {
+      const cachedData = await getCache(cacheKey);
+      if (cachedData) {
+        logger26.info(`Cache hit for key: ${cacheKey}`);
+        return cachedData;
+      }
+    } else {
+      logger26.info(`Skipping cache during transaction for key: ${cacheKey}`);
+    }
+    try {
+      const data = await collection.aggregate([
+        { $match: query },
+        {
+          $project: {
+            title: 1,
+            frequency: 1,
+            time: 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 NotFoundError7("Schedule task not found.");
+      }
+      setCache(cacheKey, data[0], 15 * 60).then(() => {
+        logger26.info(`Cache set for key: ${cacheKey}`);
+      }).catch((err) => {
+        logger26.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 ObjectId16(_id);
+    } catch (error) {
+      throw new BadRequestError27("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 ObjectId16(area.value.toString())
+          };
+        } catch (error) {
+          throw new BadRequestError27(`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 InternalServerError8(
+          "Unable to update hygiene schedule task."
+        );
+      }
+      delNamespace().then(() => {
+        logger26.info(`Cache cleared for namespace: ${namespace_collection}`);
+      }).catch((err) => {
+        logger26.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
+import { BadRequestError as BadRequestError28, logger as logger27 } from "@iservice365/node-server-utils";
+import Joi16 from "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) {
+      logger27.log({ level: "error", message: error.message });
+      next(new BadRequestError28(error.message));
+      return;
+    }
+    try {
+      const id = await _createScheduleTask(payload);
+      res.status(201).json({ message: "Schedule task created successfully.", id });
+      return;
+    } catch (error2) {
+      logger27.log({ level: "error", message: error2.message });
+      next(error2);
+      return;
+    }
+  }
+  async function getScheduleTasks(req, res, next) {
+    const query = { ...req.query, ...req.params };
+    const validation = Joi16.object({
+      page: Joi16.number().min(1).optional().allow("", null),
+      limit: Joi16.number().min(1).optional().allow("", null),
+      search: Joi16.string().optional().allow("", null),
+      site: Joi16.string().hex().required()
+    });
+    const { error } = validation.validate(query);
+    if (error) {
+      logger27.log({ level: "error", message: error.message });
+      next(new BadRequestError28(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) {
+      logger27.log({ level: "error", message: error2.message });
+      next(error2);
+      return;
+    }
+  }
+  async function getScheduleTaskById(req, res, next) {
+    const validation = Joi16.string().hex().required();
+    const _id = req.params.id;
+    const { error } = validation.validate(_id);
+    if (error) {
+      logger27.log({ level: "error", message: error.message });
+      next(new BadRequestError28(error.message));
+      return;
+    }
+    try {
+      const data = await _getScheduleTaskById(_id);
+      res.json(data);
+      return;
+    } catch (error2) {
+      logger27.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 = Joi16.object({
+      id: Joi16.string().hex().required(),
+      title: Joi16.string().optional().allow("", null),
+      frequency: Joi16.string().valid(...allowedFrequency).optional().allow("", null),
+      time: Joi16.string().pattern(/^([0-1]\d|2[0-3]):([0-5]\d)$/).optional().allow("", null),
+      day: Joi16.string().valid(...allowedDays).optional().allow("", null),
+      weekOfMonth: Joi16.string().valid(...allowedWeekOfMonth).optional().allow("", null),
+      quarter: Joi16.string().valid(...allowedQuarter).optional().allow("", null),
+      month: Joi16.string().valid(...allowedMonths).optional().allow("", null),
+      description: Joi16.string().optional().allow("", null),
+      areas: Joi16.array().min(1).items(
+        Joi16.object({
+          name: Joi16.string().required(),
+          value: Joi16.any().required()
+        })
+      ).optional()
+    });
+    const { error } = validation.validate(payload);
+    if (error) {
+      logger27.log({ level: "error", message: error.message });
+      next(new BadRequestError28(error.message));
+      return;
+    }
+    try {
+      const { id, ...value } = payload;
+      await _updateScheduleTask(id, value);
+      res.json({ message: "Schedule task updated successfully." });
+      return;
+    } catch (error2) {
+      logger27.log({ level: "error", message: error2.message });
+      next(error2);
+      return;
+    }
+  }
+  return {
+    createScheduleTask,
+    getScheduleTasks,
+    getScheduleTaskById,
+    updateScheduleTask
   };
 }
 export {
@@ -3859,17 +4578,24 @@ export {
   MAreaChecklist,
   MParentChecklist,
   MRequestItem,
+  MScheduleTask,
   MStock,
   MSupply,
   MUnit,
   allowedChecklistStatus,
+  allowedDays,
+  allowedFrequency,
+  allowedMonths,
+  allowedQuarter,
   allowedRequestItemStatus,
   allowedStatus,
   allowedTypes,
+  allowedWeekOfMonth,
   areaChecklistSchema,
   areaSchema,
   parentChecklistSchema,
   requestItemSchema,
+  scheduleTaskSchema,
   stockSchema,
   supplySchema,
   unitSchema,
@@ -3884,6 +4610,8 @@ export {
   useRequestItemController,
   useRequestItemRepository,
   useRequestItemService,
+  useScheduleTaskController,
+  useScheduleTaskRepository,
   useStockController,
   useStockRepository,
   useStockService,