@iservice365/module-hygiene 0.0.1 → 0.1.0

package/dist/index.mjs

@@ -1 +1,2781 @@
+// src/models/hygiene-area.model.ts
+import { BadRequestError, logger } from "@iservice365/node-server-utils";
+import Joi from "joi";
+import { ObjectId } from "mongodb";
+var areaSchema = Joi.object({
+  name: Joi.string().required(),
+  site: Joi.string().hex().required(),
+  createdBy: Joi.string().hex().required(),
+  checklist: Joi.array().items(
+    Joi.object({
+      _id: Joi.string().hex().required(),
+      name: Joi.string().required()
+    })
+  ).optional()
+});
+function MArea(value) {
+  const { error } = areaSchema.validate(value);
+  if (error) {
+    logger.info(`Hygiene Area Model: ${error.message}`);
+    throw new BadRequestError(error.message);
+  }
+  if (value.site) {
+    try {
+      value.site = new ObjectId(value.site);
+    } catch (error2) {
+      throw new BadRequestError("Invalid site ID format.");
+    }
+  }
+  if (value.createdBy) {
+    try {
+      value.createdBy = new ObjectId(value.createdBy);
+    } catch (error2) {
+      throw new BadRequestError("Invalid createdBy ID format.");
+    }
+  }
+  if (value.checklist && Array.isArray(value.checklist)) {
+    value.checklist = value.checklist.map((item) => {
+      try {
+        return {
+          ...item,
+          _id: new ObjectId(item._id)
+        };
+      } catch (error2) {
+        throw new BadRequestError(
+          `Invalid checklist item ID format: ${item._id}`
+        );
+      }
+    });
+  }
+  return {
+    name: value.name,
+    site: value.site,
+    createdBy: value.createdBy,
+    checklist: value.checklist,
+    status: value.status ?? "active",
+    createdAt: /* @__PURE__ */ new Date(),
+    updatedAt: value.updatedAt ?? "",
+    deletedAt: value.deletedAt ?? ""
+  };
+}
+
+// src/repositories/hygiene-area.repository.ts
+import { ObjectId as ObjectId2 } from "mongodb";
+import {
+  useAtlas,
+  InternalServerError,
+  paginate,
+  BadRequestError as BadRequestError2,
+  useCache,
+  logger as logger2,
+  makeCacheKey,
+  NotFoundError
+} from "@iservice365/node-server-utils";
+function useAreaRepository() {
+  const db = useAtlas.getDb();
+  if (!db) {
+    throw new InternalServerError("Unable to connect to server.");
+  }
+  const namespace_collection = "hygiene-areas";
+  const collection = db.collection(namespace_collection);
+  const { delNamespace, setCache, getCache } = useCache(namespace_collection);
+  async function createIndex() {
+    try {
+      await collection.createIndexes([
+        { key: { site: 1 } },
+        { key: { createdBy: 1 } },
+        { key: { status: 1 } }
+      ]);
+    } catch (error) {
+      throw new InternalServerError("Failed to create index on hygiene area.");
+    }
+  }
+  async function createTextIndex() {
+    try {
+      await collection.createIndex({ name: "text" });
+    } catch (error) {
+      throw new InternalServerError(
+        "Failed to create text index on hygiene area."
+      );
+    }
+  }
+  async function createUniqueIndex() {
+    try {
+      await collection.createIndex(
+        { name: 1, site: 1, deletedAt: 1 },
+        { unique: true }
+      );
+    } catch (error) {
+      throw new InternalServerError(
+        "Failed to create unique index on hygiene area."
+      );
+    }
+  }
+  async function createArea(value, session) {
+    try {
+      value = MArea(value);
+      const res = await collection.insertOne(value, { session });
+      delNamespace().then(() => {
+        logger2.info(`Cache cleared for namespace: ${namespace_collection}`);
+      }).catch((err) => {
+        logger2.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 BadRequestError2("Area already exists.");
+      }
+      throw error;
+    }
+  }
+  async function getAreas({
+    page = 1,
+    limit = 10,
+    search = "",
+    startDate = "",
+    endDate = "",
+    site = ""
+  }) {
+    page = page > 0 ? page - 1 : 0;
+    const query = {
+      status: { $ne: "deleted" }
+    };
+    const cacheOptions = {
+      page,
+      limit
+    };
+    if (site) {
+      try {
+        site = new ObjectId2(site);
+        cacheOptions.site = site.toString();
+      } catch (error) {
+        throw new BadRequestError2("Invalid site ID format.");
+      }
+    }
+    if (search) {
+      query.$or = [{ name: { $regex: search, $options: "i" } }];
+      cacheOptions.search = search;
+    }
+    if (startDate && endDate) {
+      query.createdAt = {
+        $gte: new Date(startDate),
+        $lte: new Date(endDate)
+      };
+      cacheOptions.startDate = new Date(startDate).toISOString().split("T")[0];
+      cacheOptions.endDate = new Date(endDate).toISOString().split("T")[0];
+    } else if (startDate) {
+      query.createdAt = { $gte: new Date(startDate) };
+      cacheOptions.startDate = new Date(startDate).toISOString().split("T")[0];
+    } else if (endDate) {
+      query.createdAt = { $lte: new Date(endDate) };
+      cacheOptions.endDate = new Date(endDate).toISOString().split("T")[0];
+    }
+    const cacheKey = makeCacheKey(namespace_collection, cacheOptions);
+    const cachedData = await getCache(cacheKey);
+    if (cachedData) {
+      logger2.info(`Cache hit for key: ${cacheKey}`);
+      return cachedData;
+    }
+    try {
+      const items = await collection.aggregate([
+        { $match: query },
+        {
+          $lookup: {
+            from: "sites",
+            localField: "site",
+            foreignField: "_id",
+            pipeline: [{ $project: { name: 1 } }],
+            as: "site"
+          }
+        },
+        {
+          $unwind: {
+            path: "$site",
+            preserveNullAndEmptyArrays: true
+          }
+        },
+        {
+          $lookup: {
+            from: "users",
+            localField: "createdBy",
+            foreignField: "_id",
+            pipeline: [{ $project: { name: 1 } }],
+            as: "createdBy"
+          }
+        },
+        {
+          $unwind: {
+            path: "$createdBy",
+            preserveNullAndEmptyArrays: true
+          }
+        },
+        {
+          $project: {
+            name: 1,
+            site: "$site._id",
+            siteName: "$site.name",
+            createdByName: "$createdBy.name",
+            checklist: 1,
+            status: 1,
+            createdAt: 1
+          }
+        },
+        { $sort: { _id: -1 } },
+        { $skip: page * limit },
+        { $limit: limit }
+      ]).toArray();
+      const length = await collection.countDocuments(query);
+      const data = paginate(items, page, limit, length);
+      setCache(cacheKey, data, 15 * 60).then(() => {
+        logger2.info(`Cache set for key: ${cacheKey}`);
+      }).catch((err) => {
+        logger2.error(`Failed to set cache for key: ${cacheKey}`, err);
+      });
+      return data;
+    } catch (error) {
+      throw error;
+    }
+  }
+  async function getAreaById(_id) {
+    try {
+      _id = new ObjectId2(_id);
+    } catch (error) {
+      throw new BadRequestError2("Invalid area ID format.");
+    }
+    const query = {
+      _id,
+      status: { $ne: "deleted" }
+    };
+    const cacheKey = makeCacheKey(namespace_collection, {
+      _id: _id.toString()
+    });
+    const cachedData = await getCache(cacheKey);
+    if (cachedData) {
+      logger2.info(`Cache hit for key: ${cacheKey}`);
+      return cachedData;
+    }
+    try {
+      const data = await collection.aggregate([
+        { $match: query },
+        {
+          $project: {
+            name: 1,
+            checklist: 1
+          }
+        }
+      ]).toArray();
+      if (!data || !data.length) {
+        throw new NotFoundError("Area not found.");
+      }
+      setCache(cacheKey, data[0], 15 * 60).then(() => {
+        logger2.info(`Cache set for key: ${cacheKey}`);
+      }).catch((err) => {
+        logger2.error(`Failed to set cache for key: ${cacheKey}`, err);
+      });
+      return data[0];
+    } catch (error) {
+      throw error;
+    }
+  }
+  async function getAreaByName(name, site) {
+    try {
+      if (site)
+        site = new ObjectId2(site);
+    } catch (error) {
+      throw new BadRequestError2("Invalid site ID format.");
+    }
+    try {
+      return await collection.findOne({
+        name: { $regex: new RegExp(`^${name}$`, "i") },
+        ...site && { site }
+      });
+    } catch (error) {
+      throw new BadRequestError2("Unable to fetch area by name.");
+    }
+  }
+  async function updateArea(_id, value) {
+    try {
+      _id = new ObjectId2(_id);
+    } catch (error) {
+      throw new BadRequestError2("Invalid area ID format.");
+    }
+    try {
+      const updateValue = { ...value, updatedAt: /* @__PURE__ */ new Date() };
+      const res = await collection.updateOne({ _id }, { $set: updateValue });
+      if (res.modifiedCount === 0) {
+        throw new InternalServerError("Unable to update cleaning area.");
+      }
+      delNamespace().then(() => {
+        logger2.info(`Cache cleared for namespace: ${namespace_collection}`);
+      }).catch((err) => {
+        logger2.error(
+          `Failed to clear cache for namespace: ${namespace_collection}`,
+          err
+        );
+      });
+      return res.modifiedCount;
+    } catch (error) {
+      const isDuplicated = error.message.includes("duplicate");
+      if (isDuplicated) {
+        throw new BadRequestError2("Area already exists.");
+      }
+      throw error;
+    }
+  }
+  async function updateAreaChecklist(_id, value) {
+    try {
+      _id = new ObjectId2(_id);
+    } catch (error) {
+      throw new BadRequestError2("Invalid area ID format.");
+    }
+    if (value.checklist && Array.isArray(value.checklist)) {
+      value.checklist = value.checklist.map((item) => {
+        try {
+          return {
+            ...item,
+            _id: new ObjectId2(item._id)
+          };
+        } catch (error) {
+          throw new BadRequestError2(
+            `Invalid checklist item ID format: ${item._id}`
+          );
+        }
+      });
+    }
+    try {
+      const updateValue = { ...value, updatedAt: /* @__PURE__ */ new Date() };
+      const res = await collection.updateOne({ _id }, { $set: updateValue });
+      if (res.modifiedCount === 0) {
+        throw new InternalServerError("Unable to update cleaning area.");
+      }
+      delNamespace().then(() => {
+        logger2.info(`Cache cleared for namespace: ${namespace_collection}`);
+      }).catch((err) => {
+        logger2.error(
+          `Failed to clear cache for namespace: ${namespace_collection}`,
+          err
+        );
+      });
+      return res.modifiedCount;
+    } catch (error) {
+      throw error;
+    }
+  }
+  async function deleteArea(_id, session) {
+    try {
+      _id = new ObjectId2(_id);
+    } catch (error) {
+      throw new BadRequestError2("Invalid area ID format.");
+    }
+    try {
+      const updateValue = {
+        status: "deleted",
+        updatedAt: /* @__PURE__ */ new Date(),
+        deletedAt: /* @__PURE__ */ new Date()
+      };
+      const res = await collection.updateOne(
+        { _id },
+        { $set: updateValue },
+        { session }
+      );
+      if (res.modifiedCount === 0) {
+        throw new InternalServerError("Unable to delete area.");
+      }
+      delNamespace().then(() => {
+        logger2.info(`Cache cleared for namespace: ${namespace_collection}`);
+      }).catch((err) => {
+        logger2.error(
+          `Failed to clear cache for namespace: ${namespace_collection}`,
+          err
+        );
+      });
+      return res.modifiedCount;
+    } catch (error) {
+      throw error;
+    }
+  }
+  return {
+    createIndex,
+    createTextIndex,
+    createUniqueIndex,
+    createArea,
+    getAreas,
+    getAreaById,
+    getAreaByName,
+    updateArea,
+    updateAreaChecklist,
+    deleteArea
+  };
+}
+
+// src/services/hygiene-area.service.ts
+import {
+  BadRequestError as BadRequestError3,
+  logger as logger3,
+  NotFoundError as NotFoundError2,
+  useAtlas as useAtlas2
+} from "@iservice365/node-server-utils";
+function useAreaService() {
+  const { createArea: _createArea } = useAreaRepository();
+  async function uploadByFile({
+    dataJson,
+    createdBy,
+    site
+  }) {
+    let dataArray;
+    try {
+      dataArray = JSON.parse(dataJson);
+    } catch (error) {
+      throw new BadRequestError3("Invalid JSON format for data in excel");
+    }
+    if (!dataArray || dataArray.length === 0) {
+      throw new NotFoundError2("No data found in the uploaded file");
+    }
+    const session = useAtlas2.getClient()?.startSession();
+    const insertedAreaIds = [];
+    try {
+      session?.startTransaction();
+      for (const row of dataArray) {
+        if (!row?.AREA_NAME) {
+          logger3.warn("Skipping row with missing AREA_NAME:", row);
+          continue;
+        }
+        try {
+          const insertedId = await _createArea(
+            {
+              name: String(row.AREA_NAME).trim(),
+              site,
+              createdBy
+            },
+            session
+          );
+          insertedAreaIds.push(insertedId);
+        } catch (error) {
+          logger3.error(
+            `Error creating area "${row.AREA_NAME}":`,
+            error.message
+          );
+          continue;
+        }
+      }
+      await session?.commitTransaction();
+      logger3.info(`Successfully uploaded ${insertedAreaIds.length} areas`);
+      return {
+        message: `Successfully uploaded ${insertedAreaIds.length} areas`
+      };
+    } catch (error) {
+      await session?.abortTransaction();
+      logger3.error("Error while uploading area information", error);
+      throw error;
+    } finally {
+      session?.endSession();
+    }
+  }
+  return {
+    uploadByFile
+  };
+}
+
+// src/controllers/hygiene-area.controller.ts
+import { BadRequestError as BadRequestError4, logger as logger4 } from "@iservice365/node-server-utils";
+import Joi2 from "joi";
+
+// src/utils/convert-excel.util.ts
+import { Readable } from "stream";
+import * as xlsx from "xlsx";
+function convertBufferFile(bufferFile) {
+  return new Promise((resolve, reject) => {
+    const fileStream = Readable.from(bufferFile);
+    let fileBuffer = Buffer.alloc(0);
+    fileStream.on("data", (chunk) => {
+      fileBuffer = Buffer.concat([fileBuffer, chunk]);
+    });
+    fileStream.on("end", () => {
+      try {
+        const workbook = xlsx.read(fileBuffer, { type: "buffer" });
+        const sheetName = workbook.SheetNames[0];
+        const sheet = workbook.Sheets[sheetName];
+        const jsonData = xlsx.utils.sheet_to_json(sheet);
+        resolve(jsonData);
+      } catch (error) {
+        reject("Error parsing file");
+      }
+    });
+    fileStream.on("error", (err) => {
+      reject("Error Reading File: " + err.message);
+    });
+  });
+}
+
+// src/controllers/hygiene-area.controller.ts
+function useAreaController() {
+  const {
+    createArea: _createArea,
+    getAreas: _getAll,
+    getAreaById: _getAreaById,
+    updateArea: _updateArea,
+    updateAreaChecklist: _updateAreaChecklist,
+    deleteArea: _deleteById
+  } = useAreaRepository();
+  const { uploadByFile: _uploadByFile } = useAreaService();
+  async function createArea(req, res, next) {
+    const cookies = req.headers.cookie ? req.headers.cookie.split(";").map((cookie) => cookie.trim().split("=")).reduce(
+      (acc, [key, value]) => ({ ...acc, [key]: value }),
+      {}
+    ) : {};
+    const createdBy = cookies["user"] || "";
+    const payload = { ...req.body, createdBy };
+    const { error } = areaSchema.validate(payload);
+    if (error) {
+      logger4.log({ level: "error", message: error.message });
+      next(new BadRequestError4(error.message));
+      return;
+    }
+    try {
+      const id = await _createArea(payload);
+      res.status(201).json({ message: "Area created successfully.", id });
+      return;
+    } catch (error2) {
+      logger4.log({ level: "error", message: error2.message });
+      next(error2);
+      return;
+    }
+  }
+  async function getAll(req, res, next) {
+    const query = req.query;
+    const validation = Joi2.object({
+      page: Joi2.number().min(1).optional().allow("", null),
+      limit: Joi2.number().min(1).optional().allow("", null),
+      search: Joi2.string().optional().allow("", null),
+      startDate: Joi2.alternatives().try(Joi2.date(), Joi2.string()).optional().allow("", null),
+      endDate: Joi2.alternatives().try(Joi2.date(), Joi2.string()).optional().allow("", null),
+      site: Joi2.string().hex().optional().allow("", null)
+    });
+    const { error } = validation.validate(query);
+    if (error) {
+      next(new BadRequestError4(error.message));
+      return;
+    }
+    const page = parseInt(req.query.page) ?? 1;
+    const limit = parseInt(req.query.limit) ?? 20;
+    const search = req.query.search ?? "";
+    const site = req.query.site ?? "";
+    const startDate = req.query.startDate ?? "";
+    const endDate = req.query.endDate ?? "";
+    try {
+      const data = await _getAll({
+        page,
+        limit,
+        search,
+        site,
+        startDate,
+        endDate
+      });
+      res.json(data);
+      return;
+    } catch (error2) {
+      next(error2);
+      return;
+    }
+  }
+  async function getAreaById(req, res, next) {
+    const validation = Joi2.string().hex().required();
+    const _id = req.params.id;
+    const { error } = validation.validate(_id);
+    if (error) {
+      logger4.log({ level: "error", message: error.message });
+      next(new BadRequestError4(error.message));
+      return;
+    }
+    try {
+      const data = await _getAreaById(_id);
+      res.json(data);
+      return;
+    } catch (error2) {
+      logger4.log({ level: "error", message: error2.message });
+      next(error2);
+      return;
+    }
+  }
+  async function updateArea(req, res, next) {
+    const payload = { id: req.params.id, ...req.body };
+    const schema = Joi2.object({
+      id: Joi2.string().hex().required(),
+      name: Joi2.string().required()
+    });
+    const { error } = schema.validate(payload);
+    if (error) {
+      logger4.log({ level: "error", message: error.message });
+      next(new BadRequestError4(error.message));
+      return;
+    }
+    try {
+      const { id, ...value } = payload;
+      await _updateArea(id, value);
+      res.json({ message: "Area updated successfully." });
+      return;
+    } catch (error2) {
+      logger4.log({ level: "error", message: error2.message });
+      next(error2);
+      return;
+    }
+  }
+  async function updateAreaChecklist(req, res, next) {
+    const payload = { id: req.params.id, ...req.body };
+    const schema = Joi2.object({
+      id: Joi2.string().hex().required(),
+      checklist: Joi2.array().items(
+        Joi2.object({
+          _id: Joi2.string().hex().required(),
+          name: Joi2.string().required()
+        }).required()
+      ).min(1).unique("_id", { ignoreUndefined: true }).messages({
+        "array.unique": "Duplicate checklist items are not allowed"
+      })
+    });
+    const { error } = schema.validate(payload);
+    if (error) {
+      logger4.log({ level: "error", message: error.message });
+      next(new BadRequestError4(error.message));
+      return;
+    }
+    try {
+      const { id, ...value } = payload;
+      await _updateAreaChecklist(id, value);
+      res.json({ message: "Area updated successfully." });
+      return;
+    } catch (error2) {
+      logger4.log({ level: "error", message: error2.message });
+      next(error2);
+      return;
+    }
+  }
+  async function deleteArea(req, res, next) {
+    const id = req.params.id;
+    const validation = Joi2.object({
+      id: Joi2.string().hex().required()
+    });
+    const { error } = validation.validate({ id });
+    if (error) {
+      logger4.log({ level: "error", message: error.message });
+      next(new BadRequestError4(error.message));
+      return;
+    }
+    try {
+      await _deleteById(id);
+      res.json({ message: "Area deleted successfully." });
+      return;
+    } catch (error2) {
+      logger4.log({ level: "error", message: error2.message });
+      next(error2);
+      return;
+    }
+  }
+  async function uploadByFile(req, res, next) {
+    if (!req.file) {
+      next(new BadRequestError4("File is required!"));
+      return;
+    }
+    const cookies = req.headers.cookie ? req.headers.cookie.split(";").map((cookie) => cookie.trim().split("=")).reduce(
+      (acc, [key, value]) => ({ ...acc, [key]: value }),
+      {}
+    ) : {};
+    const createdBy = cookies["user"] || "";
+    const { site } = req.body;
+    const schema = Joi2.object({
+      site: Joi2.string().hex().optional().allow("", null),
+      createdBy: Joi2.string().hex().required()
+    });
+    const { error } = schema.validate({ site, createdBy });
+    if (error) {
+      logger4.log({ level: "error", message: error.message });
+      next(new BadRequestError4(error.message));
+      return;
+    }
+    try {
+      const xlsData = await convertBufferFile(req.file.buffer);
+      const dataJson = JSON.stringify(xlsData);
+      const result = await _uploadByFile({ dataJson, createdBy, site });
+      return res.status(201).json(result);
+    } catch (error2) {
+      logger4.log({ level: "error", message: error2.message });
+      next(error2);
+      return;
+    }
+  }
+  return {
+    createArea,
+    getAll,
+    getAreaById,
+    updateArea,
+    updateAreaChecklist,
+    deleteArea,
+    uploadByFile
+  };
+}
+
+// src/models/hygiene-toilet-location.model.ts
+import { BadRequestError as BadRequestError5 } from "@iservice365/node-server-utils";
+import Joi3 from "joi";
+import { ObjectId as ObjectId3 } from "mongodb";
+var toiletLocationSchema = Joi3.object({
+  name: Joi3.string().required(),
+  site: Joi3.string().hex().required(),
+  createdBy: Joi3.string().hex().required(),
+  checklist: Joi3.array().items(
+    Joi3.object({
+      _id: Joi3.string().hex().required(),
+      name: Joi3.string().required()
+    })
+  ).optional(),
+  updatedAt: Joi3.date().optional().allow("", null),
+  status: Joi3.string().allow("", null).optional()
+});
+function MToiletLocation(value) {
+  const { error } = toiletLocationSchema.validate(value);
+  if (error) {
+    throw new BadRequestError5(error.message);
+  }
+  if (value.site) {
+    try {
+      value.site = new ObjectId3(value.site);
+    } catch (error2) {
+      throw new BadRequestError5("Invalid site ID format.");
+    }
+  }
+  if (value.createdBy) {
+    try {
+      value.createdBy = new ObjectId3(value.createdBy);
+    } catch (error2) {
+      throw new BadRequestError5("Invalid createdBy ID format.");
+    }
+  }
+  if (value.checklist && Array.isArray(value.checklist)) {
+    value.checklist = value.checklist.map((item) => {
+      try {
+        return {
+          ...item,
+          _id: new ObjectId3(item._id)
+        };
+      } catch (error2) {
+        throw new BadRequestError5(
+          `Invalid checklist item ID format: ${item._id}`
+        );
+      }
+    });
+  }
+  return {
+    name: value.name,
+    site: value.site,
+    createdBy: value.createdBy,
+    checklist: value.checklist,
+    status: value.status ?? "",
+    createdAt: /* @__PURE__ */ new Date(),
+    updatedAt: value.updatedAt ?? "",
+    deletedAt: value.deletedAt ?? ""
+  };
+}
+
+// src/repositories/hygiene-toilet-location.repository.ts
+import { ObjectId as ObjectId4 } from "mongodb";
+import {
+  useAtlas as useAtlas3,
+  InternalServerError as InternalServerError2,
+  paginate as paginate2,
+  BadRequestError as BadRequestError6,
+  NotFoundError as NotFoundError3,
+  useCache as useCache2,
+  logger as logger5,
+  makeCacheKey as makeCacheKey2
+} from "@iservice365/node-server-utils";
+function useToiletLocationRepository() {
+  const db = useAtlas3.getDb();
+  if (!db) {
+    throw new InternalServerError2("Unable to connect to server.");
+  }
+  const namespace_collection = "hygiene-toilet-locations";
+  const collection = db.collection(namespace_collection);
+  const { delNamespace, setCache, getCache, delCache } = useCache2(namespace_collection);
+  async function createIndexes() {
+    try {
+      await collection.createIndexes([
+        { key: { site: 1 } },
+        { key: { name: "text" } }
+      ]);
+    } catch (error) {
+      throw new InternalServerError2("Failed to create index on site.");
+    }
+  }
+  async function createUniqueIndex() {
+    try {
+      await collection.createIndex(
+        { name: 1, site: 1, deletedAt: 1 },
+        { unique: true }
+      );
+    } catch (error) {
+      throw new InternalServerError2(
+        "Failed to create unique index on hygiene area."
+      );
+    }
+  }
+  async function create(value, session) {
+    try {
+      value = MToiletLocation(value);
+      const res = await collection.insertOne(value, { session });
+      delNamespace().then(() => {
+        logger5.info(`Cache cleared for namespace: ${namespace_collection}`);
+      }).catch((err) => {
+        logger5.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 BadRequestError6("Toilet location already exists.");
+      }
+      throw error;
+    }
+  }
+  async function updateToiletLocation(_id, value) {
+    try {
+      _id = new ObjectId4(_id);
+    } catch (error) {
+      throw new BadRequestError6("Invalid area ID format.");
+    }
+    if (value.checklist && Array.isArray(value.checklist)) {
+      value.checklist = value.checklist.map((item) => {
+        try {
+          return {
+            ...item,
+            _id: new ObjectId4(item._id)
+          };
+        } catch (error) {
+          throw new BadRequestError6(
+            `Invalid checklist item ID format: ${item._id}`
+          );
+        }
+      });
+    }
+    try {
+      const updateValue = { ...value, updatedAt: /* @__PURE__ */ new Date() };
+      const res = await collection.updateOne({ _id }, { $set: updateValue });
+      if (res.modifiedCount === 0) {
+        throw new InternalServerError2("Unable to update toilet location.");
+      }
+      delNamespace().then(() => {
+        logger5.info(`Cache cleared for namespace: ${namespace_collection}`);
+      }).catch((err) => {
+        logger5.error(
+          `Failed to clear cache for namespace: ${namespace_collection}`,
+          err
+        );
+      });
+      return res.modifiedCount;
+    } catch (error) {
+      const isDuplicated = error.message.includes("duplicate");
+      if (isDuplicated) {
+        throw new BadRequestError6("Toilet location already exists.");
+      }
+      throw error;
+    }
+  }
+  async function deleteToiletLocation(_id, session) {
+    try {
+      _id = new ObjectId4(_id);
+    } catch (error) {
+      throw new BadRequestError6("Invalid area ID format.");
+    }
+    try {
+      const updateValue = {
+        status: "deleted",
+        updatedAt: /* @__PURE__ */ new Date(),
+        deletedAt: /* @__PURE__ */ new Date()
+      };
+      const res = await collection.updateOne(
+        { _id },
+        { $set: updateValue },
+        { session }
+      );
+      if (res.modifiedCount === 0) {
+        throw new InternalServerError2("Unable to delete toilet location.");
+      }
+      delNamespace().then(() => {
+        logger5.info(`Cache cleared for namespace: ${namespace_collection}`);
+      }).catch((err) => {
+        logger5.error(
+          `Failed to clear cache for namespace: ${namespace_collection}`,
+          err
+        );
+      });
+      return res.modifiedCount;
+    } catch (error) {
+      throw error;
+    }
+  }
+  async function getToiletLocations({
+    page = 1,
+    limit = 10,
+    search = "",
+    sort = {},
+    startDate = "",
+    endDate = "",
+    site = ""
+  }) {
+    page = page > 0 ? page - 1 : 0;
+    let dateFilter = {};
+    try {
+      site = new ObjectId4(site);
+    } catch (error) {
+      throw new BadRequestError6("Invalid site ID format.");
+    }
+    const query = {
+      status: { $ne: "deleted" }
+    };
+    const cacheOptions = {
+      site: site.toString()
+    };
+    sort = Object.keys(sort).length > 0 ? sort : { _id: -1 };
+    cacheOptions.sort = JSON.stringify(sort);
+    if (search) {
+      query.$or = [{ name: { $regex: search, $options: "i" } }];
+      cacheOptions.search = search;
+    }
+    delNamespace().then(() => {
+      logger5.info(`Cache cleared for namespace: ${namespace_collection}`);
+    }).catch((err) => {
+      logger5.error(
+        `Failed to clear cache for namespace: ${namespace_collection}`,
+        err
+      );
+    });
+    const cacheKey = makeCacheKey2(namespace_collection, cacheOptions);
+    const cachedData = await getCache(cacheKey);
+    if (cachedData) {
+      logger5.info(`Cache hit for key: ${cacheKey}`);
+      return cachedData;
+    }
+    if (startDate && endDate) {
+      dateFilter = {
+        createdAt: {
+          $gte: new Date(startDate),
+          $lte: new Date(endDate)
+        }
+      };
+    } else if (startDate) {
+      dateFilter = { createdAt: { $gte: new Date(startDate) } };
+    } else if (endDate) {
+      dateFilter = { createdAt: { $lte: new Date(endDate) } };
+    }
+    try {
+      const items = await collection.aggregate([
+        {
+          $match: {
+            ...dateFilter,
+            ...query
+          }
+        },
+        {
+          $lookup: {
+            from: "sites",
+            localField: "site",
+            foreignField: "_id",
+            pipeline: [{ $project: { name: 1 } }],
+            as: "site"
+          }
+        },
+        {
+          $unwind: {
+            path: "$site",
+            preserveNullAndEmptyArrays: true
+          }
+        },
+        {
+          $lookup: {
+            from: "users",
+            localField: "createdBy",
+            foreignField: "_id",
+            pipeline: [{ $project: { name: 1 } }],
+            as: "createdBy"
+          }
+        },
+        {
+          $unwind: {
+            path: "$createdBy",
+            preserveNullAndEmptyArrays: true
+          }
+        },
+        {
+          $project: {
+            name: 1,
+            site: "$site._id",
+            siteName: "$site.name",
+            createdByName: "$createdBy.name",
+            checklist: 1,
+            status: 1,
+            createdAt: 1
+          }
+        },
+        { $sort: { _id: -1 } },
+        { $skip: page * limit },
+        { $limit: limit }
+      ]).toArray();
+      const length = await collection.countDocuments(query);
+      const data = paginate2(items, page, limit, length);
+      setCache(cacheKey, data, 15 * 60).then(() => {
+        logger5.info(`Cache set for key: ${cacheKey}`);
+      }).catch((err) => {
+        logger5.error(`Failed to set cache for key: ${cacheKey}`, err);
+      });
+      return data;
+    } catch (error) {
+      throw error;
+    }
+  }
+  async function getToiletLocationByName(name, site) {
+    try {
+      if (site)
+        site = new ObjectId4(site);
+    } catch (error) {
+      throw new BadRequestError6("Invalid site ID format.");
+    }
+    try {
+      return await collection.findOne({
+        name: { $regex: new RegExp(`^${name}$`, "i") },
+        ...site && { site }
+      });
+    } catch (error) {
+      throw new BadRequestError6("Unable to fetch toilet location by name.");
+    }
+  }
+  async function updateToiletLocationChecklist(_id, value) {
+    try {
+      _id = new ObjectId4(_id);
+    } catch (error) {
+      throw new BadRequestError6("Invalid area ID format.");
+    }
+    if (value.checklist && Array.isArray(value.checklist)) {
+      value.checklist = value.checklist.map((item) => {
+        try {
+          return {
+            ...item,
+            _id: new ObjectId4(item._id)
+          };
+        } catch (error) {
+          throw new BadRequestError6(
+            `Invalid checklist item ID format: ${item._id}`
+          );
+        }
+      });
+    }
+    try {
+      const updateValue = { ...value, updatedAt: /* @__PURE__ */ new Date() };
+      const res = await collection.updateOne({ _id }, { $set: updateValue });
+      if (res.modifiedCount === 0) {
+        throw new InternalServerError2("Unable to update toilet location.");
+      }
+      delNamespace().then(() => {
+        logger5.info(`Cache cleared for namespace: ${namespace_collection}`);
+      }).catch((err) => {
+        logger5.error(
+          `Failed to clear cache for namespace: ${namespace_collection}`,
+          err
+        );
+      });
+      return res.modifiedCount;
+    } catch (error) {
+      throw error;
+    }
+  }
+  async function getToiletLocationById(_id) {
+    try {
+      _id = new ObjectId4(_id);
+    } catch (error) {
+      throw new BadRequestError6("Invalid area ID format.");
+    }
+    const query = {
+      _id,
+      status: { $ne: "deleted" }
+    };
+    const cacheKey = makeCacheKey2(namespace_collection, {
+      _id: _id.toString()
+    });
+    const cachedData = await getCache(cacheKey);
+    if (cachedData) {
+      logger5.info(`Cache hit for key: ${cacheKey}`);
+      return cachedData;
+    }
+    try {
+      const data = await collection.aggregate([
+        { $match: query },
+        {
+          $project: {
+            name: 1,
+            checklist: 1
+          }
+        }
+      ]).toArray();
+      if (!data || !data.length) {
+        throw new NotFoundError3("Area not found.");
+      }
+      setCache(cacheKey, data[0], 15 * 60).then(() => {
+        logger5.info(`Cache set for key: ${cacheKey}`);
+      }).catch((err) => {
+        logger5.error(`Failed to set cache for key: ${cacheKey}`, err);
+      });
+      return data[0];
+    } catch (error) {
+      throw error;
+    }
+  }
+  return {
+    createIndexes,
+    createUniqueIndex,
+    getToiletLocations,
+    create,
+    updateToiletLocation,
+    deleteToiletLocation,
+    getToiletLocationByName,
+    getToiletLocationById,
+    updateToiletLocationChecklist
+  };
+}
+
+// src/services/hygiene-toilet-location.service.ts
+import {
+  BadRequestError as BadRequestError7,
+  logger as logger6,
+  NotFoundError as NotFoundError4,
+  useAtlas as useAtlas4
+} from "@iservice365/node-server-utils";
+function useToiletLocationService() {
+  const { create: _createToilet } = useToiletLocationRepository();
+  async function uploadByFile({
+    dataJson,
+    createdBy,
+    site
+  }) {
+    let dataArray;
+    try {
+      dataArray = JSON.parse(dataJson);
+    } catch (error) {
+      throw new BadRequestError7("Invalid JSON format for data in excel");
+    }
+    if (!dataArray || dataArray.length === 0) {
+      throw new NotFoundError4("No data found in the uploaded file");
+    }
+    const session = useAtlas4.getClient()?.startSession();
+    const insertedAreaIds = [];
+    try {
+      session?.startTransaction();
+      for (const row of dataArray) {
+        if (!row?.AREA_NAME) {
+          logger6.warn("Skipping row with missing TOILET NAME:", row);
+          continue;
+        }
+        try {
+          const insertedId = await _createToilet(
+            {
+              name: String(row.TOILET_NAME).trim(),
+              site,
+              createdBy
+            },
+            session
+          );
+          insertedAreaIds.push(insertedId);
+        } catch (error) {
+          logger6.error(
+            `Error creating area "${row.AREA_NAME}":`,
+            error.message
+          );
+          continue;
+        }
+      }
+      await session?.commitTransaction();
+      logger6.info(`Successfully uploaded ${insertedAreaIds.length} areas`);
+      return {
+        message: `Successfully uploaded ${insertedAreaIds.length} areas`
+      };
+    } catch (error) {
+      await session?.abortTransaction();
+      logger6.error("Error while uploading area information", error);
+      throw error;
+    } finally {
+      session?.endSession();
+    }
+  }
+  return {
+    uploadByFile
+  };
+}
+
+// src/controllers/hygiene-toilet-location.controller.ts
+import Joi4 from "joi";
+import { BadRequestError as BadRequestError8, logger as logger7 } from "@iservice365/node-server-utils";
+function useToiletLocationController() {
+  const { uploadByFile: _uploadByFile } = useToiletLocationService();
+  const {
+    create: _createToiletLocation,
+    updateToiletLocation: _updateToiletLocation,
+    updateToiletLocationChecklist: _updateToiletLocationChecklist,
+    getToiletLocationById: _getToiletLocationById,
+    getToiletLocations: _getAll,
+    deleteToiletLocation: _deleteById
+  } = useToiletLocationRepository();
+  async function getAll(req, res, next) {
+    const query = req.query;
+    const validation = Joi4.object({
+      page: Joi4.number().min(1).optional().allow("", null),
+      limit: Joi4.number().min(1).optional().allow("", null),
+      search: Joi4.string().optional().allow("", null),
+      site: Joi4.string().hex().optional().allow("", null)
+    });
+    const { error } = validation.validate(query);
+    if (error) {
+      next(new BadRequestError8(error.message));
+      return;
+    }
+    const page = parseInt(req.query.page) ?? 1;
+    let limit = parseInt(req.query.limit) ?? 20;
+    limit = isNaN(limit) ? 20 : limit;
+    const sort = req.query.sort ? String(req.query.sort).split(",") : "";
+    const sortOrder = req.query.sortOrder ? String(req.query.sortOrder).split(",") : "";
+    const sortObj = {};
+    if (sort && Array.isArray(sort) && sort.length && sortOrder && Array.isArray(sortOrder) && sortOrder.length) {
+      sort.forEach((field, index) => {
+        sortObj[field] = sortOrder[index] === "desc" ? -1 : 1;
+      });
+    }
+    const site = req.query.site ?? "";
+    const search = req.query.search ?? "";
+    try {
+      const buildings = await _getAll({
+        page,
+        limit,
+        sort: sortObj,
+        site,
+        search
+      });
+      res.json(buildings);
+      return;
+    } catch (error2) {
+      next(error2);
+    }
+  }
+  async function createToiletLocation(req, res, next) {
+    const cookies = req.headers.cookie ? req.headers.cookie.split(";").map((cookie) => cookie.trim().split("=")).reduce(
+      (acc, [key, value]) => ({ ...acc, [key]: value }),
+      {}
+    ) : {};
+    const createdBy = cookies["user"] || "";
+    const payload = { ...req.body, createdBy };
+    const schema = Joi4.object({
+      name: Joi4.string().required(),
+      site: Joi4.string().hex().optional().allow("", null),
+      status: Joi4.string().optional().allow("", null),
+      createdBy: Joi4.string().hex().optional().allow("", null)
+    });
+    const { error } = schema.validate(payload);
+    if (error) {
+      next(new BadRequestError8(error.message));
+      logger7.info(`Controller: ${error.message}`);
+      return;
+    }
+    try {
+      const result = await _createToiletLocation(payload);
+      res.status(201).json(result);
+      return;
+    } catch (error2) {
+      next(error2);
+    }
+  }
+  async function updateToiletLocation(req, res, next) {
+    const payload = { id: req.params.id, ...req.body };
+    const schema = Joi4.object({
+      id: Joi4.string().hex().required(),
+      name: Joi4.string().required(),
+      checklist: Joi4.array().items(
+        Joi4.object({
+          _id: Joi4.string().hex().required(),
+          name: Joi4.string().required()
+        }).optional()
+      ),
+      site: Joi4.string().hex().optional().allow("", null),
+      status: Joi4.string().optional().allow("", null)
+    });
+    const { error } = schema.validate(payload);
+    if (error) {
+      logger7.log({ level: "error", message: error.message });
+      next(new BadRequestError8(error.message));
+      return;
+    }
+    try {
+      const { id, ...value } = payload;
+      await _updateToiletLocation(id, value);
+      res.status(201).json({ message: "Toilet location updated successfully." });
+      return;
+    } catch (error2) {
+      logger7.log({ level: "error", message: error2.message });
+      next(error2);
+    }
+  }
+  async function deleteToiletLocation(req, res, next) {
+    const id = req.params.id;
+    const validation = Joi4.object({
+      id: Joi4.string().hex().required()
+    });
+    const { error } = validation.validate({ id });
+    if (error) {
+      next(new BadRequestError8(error.message));
+      return;
+    }
+    try {
+      const message = await _deleteById(id);
+      res.json(message);
+      return;
+    } catch (error2) {
+      next(error2);
+    }
+  }
+  async function updateToiletLocationChecklist(req, res, next) {
+    const payload = { id: req.params.id, ...req.body };
+    const schema = Joi4.object({
+      id: Joi4.string().hex().required(),
+      checklist: Joi4.array().items(
+        Joi4.object({
+          _id: Joi4.string().hex().required(),
+          name: Joi4.string().required()
+        }).required()
+      ).min(1).unique("_id", { ignoreUndefined: true }).messages({
+        "array.unique": "Duplicate checklist items are not allowed"
+      })
+    });
+    const { error } = schema.validate(payload);
+    if (error) {
+      logger7.log({ level: "error", message: error.message });
+      next(new BadRequestError8(error.message));
+      return;
+    }
+    try {
+      const { id, ...value } = payload;
+      await _updateToiletLocationChecklist(id, value);
+      res.json({ message: "Toilet location updated successfully." });
+      return;
+    } catch (error2) {
+      logger7.log({ level: "error", message: error2.message });
+      next(error2);
+      return;
+    }
+  }
+  async function getToiletLocationById(req, res, next) {
+    const validation = Joi4.string().hex().required();
+    const _id = req.params.id;
+    const { error } = validation.validate(_id);
+    if (error) {
+      logger7.log({ level: "error", message: error.message });
+      next(new BadRequestError8(error.message));
+      return;
+    }
+    try {
+      const data = await _getToiletLocationById(_id);
+      res.json(data);
+      return;
+    } catch (error2) {
+      logger7.log({ level: "error", message: error2.message });
+      next(error2);
+      return;
+    }
+  }
+  async function uploadByFile(req, res, next) {
+    if (!req.file) {
+      next(new BadRequestError8("File is required!"));
+      return;
+    }
+    const cookies = req.headers.cookie ? req.headers.cookie.split(";").map((cookie) => cookie.trim().split("=")).reduce(
+      (acc, [key, value]) => ({ ...acc, [key]: value }),
+      {}
+    ) : {};
+    const createdBy = cookies["user"] || "";
+    const { site } = req.body;
+    const schema = Joi4.object({
+      site: Joi4.string().hex().optional().allow("", null),
+      createdBy: Joi4.string().hex().required()
+    });
+    const { error } = schema.validate({ site, createdBy });
+    if (error) {
+      logger7.log({ level: "error", message: error.message });
+      next(new BadRequestError8(error.message));
+      return;
+    }
+    try {
+      const xlsData = await convertBufferFile(req.file.buffer);
+      const dataJson = JSON.stringify(xlsData);
+      const result = await _uploadByFile({ dataJson, createdBy, site });
+      return res.status(201).json(result);
+    } catch (error2) {
+      logger7.log({ level: "error", message: error2.message });
+      next(error2);
+      return;
+    }
+  }
+  return {
+    getAll,
+    createToiletLocation,
+    updateToiletLocation,
+    deleteToiletLocation,
+    updateToiletLocationChecklist,
+    getToiletLocationById,
+    uploadByFile
+  };
+}
+
+// src/models/hygiene-parent-checklist.model.ts
+import { BadRequestError as BadRequestError9 } from "@iservice365/node-server-utils";
+import Joi5 from "joi";
+var parentChecklistSchema = Joi5.object({
+  date: Joi5.date().required(),
+  status: Joi5.array().items(
+    Joi5.object({
+      site: Joi5.string().hex().required(),
+      status: Joi5.string().required(),
+      completedAt: Joi5.date().required(),
+      type: Joi5.string().required()
+    })
+  ).optional(),
+  updatedAt: Joi5.date().optional().allow("", null)
+});
+function MParentChecklist(value) {
+  const { error } = parentChecklistSchema.validate(value);
+  if (error) {
+    throw new BadRequestError9(error.message);
+  }
+  return {
+    date: value.date,
+    status: value.status,
+    createdAt: /* @__PURE__ */ new Date(),
+    updatedAt: value.updatedAt ?? "",
+    deletedAt: value.deletedAt ?? ""
+  };
+}
+
+// src/repositories/hygiene-parent-checklist.repository.ts
+import {
+  useAtlas as useAtlas5,
+  InternalServerError as InternalServerError3,
+  paginate as paginate3,
+  useCache as useCache3,
+  logger as logger8,
+  makeCacheKey as makeCacheKey3
+} from "@iservice365/node-server-utils";
+function useParentChecklistRepo() {
+  const db = useAtlas5.getDb();
+  if (!db) {
+    throw new InternalServerError3("Unable to connect to server.");
+  }
+  const namespace_collection = "hygiene-parent-checklist";
+  const collection = db.collection(namespace_collection);
+  const { delNamespace, setCache, getCache, delCache } = useCache3(namespace_collection);
+  async function createIndexes() {
+    try {
+      await collection.createIndexes([
+        { key: { date: "text" } }
+      ]);
+    } catch (error) {
+      throw new InternalServerError3("Failed to create index on site.");
+    }
+  }
+  async function create(value, session) {
+    try {
+      const currentDate = /* @__PURE__ */ new Date();
+      const startOfDay = new Date(currentDate);
+      startOfDay.setDate(currentDate.getDate());
+      startOfDay.setUTCHours(0, 0, 0, 0);
+      const endOfDay = new Date(currentDate);
+      endOfDay.setDate(currentDate.getDate());
+      endOfDay.setUTCHours(23, 59, 59, 999);
+      const checklistRecord = await collection.findOne({
+        date: {
+          $gte: startOfDay,
+          $lte: endOfDay
+        }
+      });
+      delNamespace().then(() => {
+        logger8.info(`Cache cleared for namespace: ${namespace_collection}`);
+      }).catch((err) => {
+        logger8.error(
+          `Failed to clear cache for namespace: ${namespace_collection}`,
+          err
+        );
+      });
+      if (!checklistRecord) {
+        value = MParentChecklist(value);
+        const res = await collection.insertOne(value, { session });
+        return res.insertedId;
+      }
+      return checklistRecord;
+    } catch (error) {
+      throw error;
+    }
+  }
+  async function get({
+    page = 1,
+    limit = 10,
+    search = "",
+    sort = {},
+    startDate = "",
+    endDate = ""
+  }) {
+    page = page > 0 ? page - 1 : 0;
+    let dateFilter = {};
+    const query = {
+      createdAt: {
+        createdAt: {
+          $gte: new Date(startDate),
+          $lte: new Date(endDate)
+        }
+      }
+    };
+    const cacheOptions = {
+      createdAt: {
+        createdAt: {
+          $gte: new Date(startDate),
+          $lte: new Date(endDate)
+        }
+      }
+    };
+    sort = Object.keys(sort).length > 0 ? sort : { _id: -1 };
+    cacheOptions.sort = JSON.stringify(sort);
+    if (search) {
+      query.$or = [{ name: { $regex: search, $options: "i" } }];
+      cacheOptions.search = search;
+    }
+    delNamespace().then(() => {
+      logger8.info(`Cache cleared for namespace: ${namespace_collection}`);
+    }).catch((err) => {
+      logger8.error(
+        `Failed to clear cache for namespace: ${namespace_collection}`,
+        err
+      );
+    });
+    const cacheKey = makeCacheKey3(namespace_collection, cacheOptions);
+    const cachedData = await getCache(cacheKey);
+    if (cachedData) {
+      logger8.info(`Cache hit for key: ${cacheKey}`);
+      return cachedData;
+    }
+    if (startDate && endDate) {
+      dateFilter = {
+        createdAt: {
+          $gte: new Date(startDate),
+          $lte: new Date(endDate)
+        }
+      };
+    } else if (startDate) {
+      dateFilter = { createdAt: { $gte: new Date(startDate) } };
+    } else if (endDate) {
+      dateFilter = { createdAt: { $lte: new Date(endDate) } };
+    }
+    try {
+      const items = await collection.aggregate([
+        {
+          $match: {
+            ...dateFilter
+          }
+        },
+        {
+          $facet: {
+            totalCount: [{ $count: "count" }],
+            items: [
+              { $sort: { createdAt: -1 } },
+              { $skip: page * limit },
+              { $limit: limit }
+            ]
+          }
+        }
+      ]).toArray();
+      const length = await collection.countDocuments(dateFilter);
+      const data = paginate3(items, page, limit, length);
+      setCache(cacheKey, data, 15 * 60).then(() => {
+        logger8.info(`Cache set for key: ${cacheKey}`);
+      }).catch((err) => {
+        logger8.error(`Failed to set cache for key: ${cacheKey}`, err);
+      });
+      return data;
+    } catch (error) {
+      throw error;
+    }
+  }
+  return {
+    createIndexes,
+    create,
+    get
+  };
+}
+
+// src/controllers/hygiene-parent-checklist.controller.ts
+import { BadRequestError as BadRequestError11, logger as logger9 } from "@iservice365/node-server-utils";
+import Joi6 from "joi";
+function useParentCheckilstController() {
+  const {
+    get: _getAll,
+    create: _create
+  } = useParentChecklistRepo();
+  async function getAll(req, res, next) {
+    const query = req.query;
+    const validation = Joi6.object({
+      page: Joi6.number().min(1).optional().allow("", null),
+      limit: Joi6.number().min(1).optional().allow("", null)
+    });
+    const { error } = validation.validate(query);
+    if (error) {
+      next(new BadRequestError11(error.message));
+      return;
+    }
+    const page = parseInt(req.query.page) ?? 1;
+    let limit = parseInt(req.query.limit) ?? 20;
+    limit = isNaN(limit) ? 20 : limit;
+    const sort = req.query.sort ? String(req.query.sort).split(",") : "";
+    const sortOrder = req.query.sortOrder ? String(req.query.sortOrder).split(",") : "";
+    const sortObj = {};
+    if (sort && Array.isArray(sort) && sort.length && sortOrder && Array.isArray(sortOrder) && sortOrder.length) {
+      sort.forEach((field, index) => {
+        sortObj[field] = sortOrder[index] === "desc" ? -1 : 1;
+      });
+    }
+    const site = req.query.site ?? "";
+    const search = req.query.search ?? "";
+    try {
+      const buildings = await _getAll({
+        page,
+        limit,
+        sort: sortObj,
+        site,
+        search
+      });
+      res.json(buildings);
+      return;
+    } catch (error2) {
+      next(error2);
+    }
+  }
+  async function create(req, res, next) {
+    const value = req.body;
+    const schema = Joi6.object({
+      date: Joi6.string().required()
+    });
+    const { error } = schema.validate(value);
+    if (error) {
+      next(new BadRequestError11(error.message));
+      logger9.info(`Controller: ${error.message}`);
+      return;
+    }
+    try {
+      const result = await _create(value);
+      res.status(201).json(result);
+      return;
+    } catch (error2) {
+      next(error2);
+    }
+  }
+  return {
+    getAll,
+    create
+  };
+}
+
+// src/models/hygiene-unit.model.ts
+import { BadRequestError as BadRequestError12, logger as logger10 } from "@iservice365/node-server-utils";
+import Joi7 from "joi";
+import { ObjectId as ObjectId5 } from "mongodb";
+var unitSchema = Joi7.object({
+  name: Joi7.string().required(),
+  site: Joi7.string().hex().required(),
+  createdBy: Joi7.string().hex().required()
+});
+function MUnit(value) {
+  const { error } = unitSchema.validate(value);
+  if (error) {
+    logger10.info(`Hygiene Unit Model: ${error.message}`);
+    throw new BadRequestError12(error.message);
+  }
+  if (value.site) {
+    try {
+      value.site = new ObjectId5(value.site);
+    } catch (error2) {
+      throw new BadRequestError12("Invalid site ID format.");
+    }
+  }
+  if (value.createdBy) {
+    try {
+      value.createdBy = new ObjectId5(value.createdBy);
+    } catch (error2) {
+      throw new BadRequestError12("Invalid createdBy ID format.");
+    }
+  }
+  return {
+    name: value.name,
+    createdBy: value.createdBy,
+    site: value.site,
+    status: "active",
+    createdAt: /* @__PURE__ */ new Date(),
+    updatedAt: value.updatedAt ?? "",
+    deletedAt: value.deletedAt ?? ""
+  };
+}
+
+// src/services/hygiene-unit.service.ts
+import {
+  BadRequestError as BadRequestError14,
+  logger as logger12,
+  NotFoundError as NotFoundError6,
+  useAtlas as useAtlas7
+} from "@iservice365/node-server-utils";
+
+// src/repositories/hygiene-unit.repository.ts
+import { ObjectId as ObjectId6 } from "mongodb";
+import {
+  useAtlas as useAtlas6,
+  InternalServerError as InternalServerError4,
+  paginate as paginate4,
+  BadRequestError as BadRequestError13,
+  useCache as useCache4,
+  logger as logger11,
+  makeCacheKey as makeCacheKey4
+} from "@iservice365/node-server-utils";
+function useUnitRepository() {
+  const db = useAtlas6.getDb();
+  if (!db) {
+    throw new InternalServerError4("Unable to connect to server.");
+  }
+  const namespace_collection = "hygiene-units";
+  const collection = db.collection(namespace_collection);
+  const { delNamespace, setCache, getCache } = useCache4(namespace_collection);
+  async function createIndex() {
+    try {
+      await collection.createIndexes([
+        { key: { site: 1 } },
+        { key: { createdBy: 1 } },
+        { key: { status: 1 } }
+      ]);
+    } catch (error) {
+      throw new InternalServerError4("Failed to create index on hygiene unit.");
+    }
+  }
+  async function createTextIndex() {
+    try {
+      await collection.createIndex({ name: "text" });
+    } catch (error) {
+      throw new InternalServerError4(
+        "Failed to create text index on hygiene unit."
+      );
+    }
+  }
+  async function createUniqueIndex() {
+    try {
+      await collection.createIndex(
+        { name: 1, site: 1, deletedAt: 1 },
+        { unique: true }
+      );
+    } catch (error) {
+      throw new InternalServerError4(
+        "Failed to create unique index on hygiene unit."
+      );
+    }
+  }
+  async function createUnit(value, session) {
+    try {
+      value = MUnit(value);
+      const res = await collection.insertOne(value, { session });
+      delNamespace().then(() => {
+        logger11.info(`Cache cleared for namespace: ${namespace_collection}`);
+      }).catch((err) => {
+        logger11.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 BadRequestError13("Unit already exists.");
+      }
+      throw error;
+    }
+  }
+  async function getUnits({
+    page = 1,
+    limit = 10,
+    search = "",
+    startDate = "",
+    endDate = "",
+    site = ""
+  }) {
+    page = page > 0 ? page - 1 : 0;
+    try {
+      site = new ObjectId6(site);
+    } catch (error) {
+      throw new BadRequestError13("Invalid site ID format.");
+    }
+    const query = {
+      status: { $ne: "deleted" },
+      site
+    };
+    const cacheOptions = {
+      page,
+      limit,
+      site: site.toString()
+    };
+    if (search) {
+      query.$or = [{ name: { $regex: search, $options: "i" } }];
+      cacheOptions.search = search;
+    }
+    if (startDate && endDate) {
+      query.createdAt = {
+        $gte: new Date(startDate),
+        $lte: new Date(endDate)
+      };
+      cacheOptions.startDate = new Date(startDate).toISOString().split("T")[0];
+      cacheOptions.endDate = new Date(endDate).toISOString().split("T")[0];
+    } else if (startDate) {
+      query.createdAt = { $gte: new Date(startDate) };
+      cacheOptions.startDate = new Date(startDate).toISOString().split("T")[0];
+    } else if (endDate) {
+      query.createdAt = { $lte: new Date(endDate) };
+      cacheOptions.endDate = new Date(endDate).toISOString().split("T")[0];
+    }
+    const cacheKey = makeCacheKey4(namespace_collection, cacheOptions);
+    const cachedData = await getCache(cacheKey);
+    if (cachedData) {
+      logger11.info(`Cache hit for key: ${cacheKey}`);
+      return cachedData;
+    }
+    try {
+      const items = await collection.aggregate([
+        { $match: query },
+        {
+          $lookup: {
+            from: "sites",
+            localField: "site",
+            foreignField: "_id",
+            pipeline: [{ $project: { name: 1 } }],
+            as: "site"
+          }
+        },
+        {
+          $unwind: {
+            path: "$site",
+            preserveNullAndEmptyArrays: true
+          }
+        },
+        {
+          $lookup: {
+            from: "users",
+            localField: "createdBy",
+            foreignField: "_id",
+            pipeline: [{ $project: { name: 1 } }],
+            as: "createdBy"
+          }
+        },
+        {
+          $unwind: {
+            path: "$createdBy",
+            preserveNullAndEmptyArrays: true
+          }
+        },
+        {
+          $project: {
+            name: 1,
+            site: "$site._id",
+            siteName: "$site.name",
+            createdByName: "$createdBy.name",
+            checklist: 1,
+            status: 1,
+            createdAt: 1
+          }
+        },
+        { $sort: { _id: -1 } },
+        { $skip: page * limit },
+        { $limit: limit }
+      ]).toArray();
+      const length = await collection.countDocuments(query);
+      const data = paginate4(items, page, limit, length);
+      setCache(cacheKey, data, 15 * 60).then(() => {
+        logger11.info(`Cache set for key: ${cacheKey}`);
+      }).catch((err) => {
+        logger11.error(`Failed to set cache for key: ${cacheKey}`, err);
+      });
+      return data;
+    } catch (error) {
+      throw error;
+    }
+  }
+  async function getUnitByName(name, site) {
+    try {
+      if (site)
+        site = new ObjectId6(site);
+    } catch (error) {
+      throw new BadRequestError13("Invalid site ID format.");
+    }
+    try {
+      return await collection.findOne({
+        name: { $regex: new RegExp(`^${name}$`, "i") },
+        ...site && { site }
+      });
+    } catch (error) {
+      throw new BadRequestError13("Unable to fetch unit by name.");
+    }
+  }
+  async function getUnitById(id, site) {
+    try {
+      id = typeof id === "string" ? new ObjectId6(id) : id;
+    } catch (error) {
+      throw new BadRequestError13("Invalid unit ID format.");
+    }
+    try {
+      if (site)
+        site = new ObjectId6(site);
+    } catch (error) {
+      throw new BadRequestError13(
+        "Unable to fetch unit by ID, Invalid site ID format."
+      );
+    }
+    try {
+      return await collection.findOne({ _id: id, ...site && { site } });
+    } catch (error) {
+      throw new BadRequestError13("Unable to fetch unit by id.");
+    }
+  }
+  async function updateUnit(_id, value) {
+    try {
+      _id = new ObjectId6(_id);
+    } catch (error) {
+      throw new BadRequestError13("Invalid unit ID format.");
+    }
+    try {
+      const updateValue = { ...value, updatedAt: /* @__PURE__ */ new Date() };
+      const res = await collection.updateOne({ _id }, { $set: updateValue });
+      if (res.modifiedCount === 0) {
+        throw new InternalServerError4("Unable to update cleaning unit.");
+      }
+      delNamespace().then(() => {
+        logger11.info(`Cache cleared for namespace: ${namespace_collection}`);
+      }).catch((err) => {
+        logger11.error(
+          `Failed to clear cache for namespace: ${namespace_collection}`,
+          err
+        );
+      });
+      return res.modifiedCount;
+    } catch (error) {
+      const isDuplicated = error.message.includes("duplicate");
+      if (isDuplicated) {
+        throw new BadRequestError13("Area already exists.");
+      }
+      throw error;
+    }
+  }
+  async function deleteUnit(_id, session) {
+    try {
+      _id = new ObjectId6(_id);
+    } catch (error) {
+      throw new BadRequestError13("Invalid unit ID format.");
+    }
+    try {
+      const updateValue = {
+        status: "deleted",
+        updatedAt: /* @__PURE__ */ new Date(),
+        deletedAt: /* @__PURE__ */ new Date()
+      };
+      const res = await collection.updateOne(
+        { _id },
+        { $set: updateValue },
+        { session }
+      );
+      if (res.modifiedCount === 0) {
+        throw new InternalServerError4("Unable to delete unit.");
+      }
+      delNamespace().then(() => {
+        logger11.info(`Cache cleared for namespace: ${namespace_collection}`);
+      }).catch((err) => {
+        logger11.error(
+          `Failed to clear cache for namespace: ${namespace_collection}`,
+          err
+        );
+      });
+      return res.modifiedCount;
+    } catch (error) {
+      throw error;
+    }
+  }
+  return {
+    createIndex,
+    createTextIndex,
+    createUniqueIndex,
+    createUnit,
+    getUnits,
+    getUnitByName,
+    getUnitById,
+    updateUnit,
+    deleteUnit
+  };
+}
+
+// src/services/hygiene-unit.service.ts
+function useUnitService() {
+  const { createUnit: _createUnit } = useUnitRepository();
+  async function uploadByFile({
+    dataJson,
+    createdBy,
+    site
+  }) {
+    let dataArray;
+    try {
+      dataArray = JSON.parse(dataJson);
+    } catch (error) {
+      throw new BadRequestError14("Invalid JSON format for data in excel");
+    }
+    if (!dataArray || dataArray.length === 0) {
+      throw new NotFoundError6("No data found in the uploaded file");
+    }
+    const session = useAtlas7.getClient()?.startSession();
+    const insertedUnitIds = [];
+    try {
+      session?.startTransaction();
+      for (const row of dataArray) {
+        if (!row?.UNIT_NAME) {
+          logger12.warn("Skipping row with missing UNIT_NAME:", row);
+          continue;
+        }
+        try {
+          const insertedId = await _createUnit(
+            {
+              name: String(row.UNIT_NAME).trim(),
+              site,
+              createdBy
+            },
+            session
+          );
+          insertedUnitIds.push(insertedId);
+        } catch (error) {
+          logger12.error(
+            `Error creating unit "${row.UNIT_NAME}":`,
+            error.message
+          );
+          continue;
+        }
+      }
+      await session?.commitTransaction();
+      logger12.info(`Successfully uploaded ${insertedUnitIds.length} units`);
+      return {
+        message: `Successfully uploaded ${insertedUnitIds.length} units`
+      };
+    } catch (error) {
+      await session?.abortTransaction();
+      logger12.error("Error while uploading unit information", error);
+      throw error;
+    } finally {
+      session?.endSession();
+    }
+  }
+  return {
+    uploadByFile
+  };
+}
+
+// src/controllers/hygiene-unit.controller.ts
+import { BadRequestError as BadRequestError15, logger as logger13 } from "@iservice365/node-server-utils";
+import Joi8 from "joi";
+function useUnitController() {
+  const {
+    createUnit: _createUnit,
+    getUnits: _getUnits,
+    updateUnit: _updateUnit,
+    deleteUnit: _deleteUnit
+  } = useUnitRepository();
+  const { uploadByFile: _uploadByFile } = useUnitService();
+  async function createUnit(req, res, next) {
+    const cookies = req.headers.cookie ? req.headers.cookie.split(";").map((cookie) => cookie.trim().split("=")).reduce(
+      (acc, [key, value]) => ({ ...acc, [key]: value }),
+      {}
+    ) : {};
+    const createdBy = cookies["user"] || "";
+    const payload = { ...req.body, createdBy };
+    const { error } = unitSchema.validate(payload);
+    if (error) {
+      logger13.log({ level: "error", message: error.message });
+      next(new BadRequestError15(error.message));
+      return;
+    }
+    try {
+      const id = await _createUnit(payload);
+      res.status(201).json({ message: "Unit created successfully.", id });
+      return;
+    } catch (error2) {
+      logger13.log({ level: "error", message: error2.message });
+      next(error2);
+      return;
+    }
+  }
+  async function getAll(req, res, next) {
+    const query = req.query;
+    const validation = Joi8.object({
+      page: Joi8.number().min(1).optional().allow("", null),
+      limit: Joi8.number().min(1).optional().allow("", null),
+      search: Joi8.string().optional().allow("", null),
+      startDate: Joi8.alternatives().try(Joi8.date(), Joi8.string()).optional().allow("", null),
+      endDate: Joi8.alternatives().try(Joi8.date(), Joi8.string()).optional().allow("", null),
+      site: Joi8.string().hex().optional().allow("", null)
+    });
+    const { error } = validation.validate(query);
+    if (error) {
+      logger13.log({ level: "error", message: error.message });
+      next(new BadRequestError15(error.message));
+      return;
+    }
+    const page = parseInt(req.query.page) ?? 1;
+    const limit = parseInt(req.query.limit) ?? 20;
+    const search = req.query.search ?? "";
+    const site = req.query.site ?? "";
+    const startDate = req.query.startDate ?? "";
+    const endDate = req.query.endDate ?? "";
+    try {
+      const data = await _getUnits({
+        page,
+        limit,
+        search,
+        site,
+        startDate,
+        endDate
+      });
+      res.json(data);
+      return;
+    } catch (error2) {
+      logger13.log({ level: "error", message: error2.message });
+      next(error2);
+      return;
+    }
+  }
+  async function updateUnit(req, res, next) {
+    const payload = { id: req.params.id, ...req.body };
+    const schema = Joi8.object({
+      id: Joi8.string().hex().required(),
+      name: Joi8.string().required()
+    });
+    const { error } = schema.validate(payload);
+    if (error) {
+      logger13.log({ level: "error", message: error.message });
+      next(new BadRequestError15(error.message));
+      return;
+    }
+    try {
+      const { id, ...value } = payload;
+      await _updateUnit(id, value);
+      res.json({ message: "Unit updated successfully." });
+      return;
+    } catch (error2) {
+      logger13.log({ level: "error", message: error2.message });
+      next(error2);
+      return;
+    }
+  }
+  async function deleteUnit(req, res, next) {
+    const id = req.params.id;
+    const validation = Joi8.object({
+      id: Joi8.string().hex().required()
+    });
+    const { error } = validation.validate({ id });
+    if (error) {
+      logger13.log({ level: "error", message: error.message });
+      next(new BadRequestError15(error.message));
+      return;
+    }
+    try {
+      await _deleteUnit(id);
+      res.json({ message: "Unit deleted successfully." });
+      return;
+    } catch (error2) {
+      logger13.log({ level: "error", message: error2.message });
+      next(error2);
+      return;
+    }
+  }
+  async function uploadByFile(req, res, next) {
+    if (!req.file) {
+      next(new BadRequestError15("File is required!"));
+      return;
+    }
+    const cookies = req.headers.cookie ? req.headers.cookie.split(";").map((cookie) => cookie.trim().split("=")).reduce(
+      (acc, [key, value]) => ({ ...acc, [key]: value }),
+      {}
+    ) : {};
+    const createdBy = cookies["user"] || "";
+    const { site } = req.body;
+    const schema = Joi8.object({
+      site: Joi8.string().hex().optional().allow("", null),
+      createdBy: Joi8.string().hex().required()
+    });
+    const { error } = schema.validate({ site, createdBy });
+    if (error) {
+      logger13.log({ level: "error", message: error.message });
+      next(new BadRequestError15(error.message));
+      return;
+    }
+    try {
+      const xlsData = await convertBufferFile(req.file.buffer);
+      const dataJson = JSON.stringify(xlsData);
+      const result = await _uploadByFile({ dataJson, createdBy, site });
+      return res.status(201).json(result);
+    } catch (error2) {
+      logger13.log({ level: "error", message: error2.message });
+      next(error2);
+      return;
+    }
+  }
+  return {
+    createUnit,
+    getAll,
+    updateUnit,
+    deleteUnit,
+    uploadByFile
+  };
+}
+
+// src/models/hygiene-schedule-task-area.model.ts
+import { BadRequestError as BadRequestError16 } from "@iservice365/node-server-utils";
+import Joi9 from "joi";
+import { ObjectId as ObjectId7 } from "mongodb";
+var scheduleTaskAreaSchema = Joi9.object({
+  name: Joi9.string().required(),
+  site: Joi9.string().hex().required(),
+  createdBy: Joi9.string().hex().required(),
+  checklist: Joi9.array().items(
+    Joi9.object({
+      _id: Joi9.string().hex().required(),
+      name: Joi9.string().required()
+    })
+  ).optional(),
+  updatedAt: Joi9.date().optional().allow("", null),
+  status: Joi9.string().allow("", null).optional()
+});
+function MScheduleTaskArea(value) {
+  const { error } = scheduleTaskAreaSchema.validate(value);
+  if (error) {
+    throw new BadRequestError16(error.message);
+  }
+  if (value.site) {
+    try {
+      value.site = new ObjectId7(value.site);
+    } catch (error2) {
+      throw new BadRequestError16("Invalid site ID format.");
+    }
+  }
+  if (value.createdBy) {
+    try {
+      value.createdBy = new ObjectId7(value.createdBy);
+    } catch (error2) {
+      throw new BadRequestError16("Invalid createdBy ID format.");
+    }
+  }
+  if (value.checklist && Array.isArray(value.checklist)) {
+    value.checklist = value.checklist.map((item) => {
+      try {
+        return {
+          ...item,
+          _id: new ObjectId7(item._id)
+        };
+      } catch (error2) {
+        throw new BadRequestError16(
+          `Invalid checklist item ID format: ${item._id}`
+        );
+      }
+    });
+  }
+  return {
+    name: value.name,
+    site: value.site,
+    createdBy: value.createdBy,
+    checklist: value.checklist,
+    status: value.status ?? "",
+    createdAt: /* @__PURE__ */ new Date(),
+    updatedAt: value.updatedAt ?? "",
+    deletedAt: value.deletedAt ?? ""
+  };
+}
+
+// src/repositories/hygiene-schedule-task-area.repository.ts
+import { ObjectId as ObjectId8 } from "mongodb";
+import {
+  useAtlas as useAtlas8,
+  InternalServerError as InternalServerError5,
+  paginate as paginate5,
+  BadRequestError as BadRequestError17,
+  useCache as useCache5,
+  logger as logger14,
+  makeCacheKey as makeCacheKey5
+} from "@iservice365/node-server-utils";
+function useScheduleTaskAreaRepository() {
+  const db = useAtlas8.getDb();
+  if (!db) {
+    throw new InternalServerError5("Unable to connect to server.");
+  }
+  const namespace_collection = "hygiene-schedule-task-areas";
+  const collection = db.collection(namespace_collection);
+  const { delNamespace, setCache, getCache, delCache } = useCache5(namespace_collection);
+  async function createIndexes() {
+    try {
+      await collection.createIndexes([
+        { key: { site: 1 } },
+        { key: { name: "text" } }
+      ]);
+    } catch (error) {
+      throw new InternalServerError5("Failed to create index on site.");
+    }
+  }
+  async function createScheduleTaskArea(value, session) {
+    try {
+      value = MScheduleTaskArea(value);
+      const res = await collection.insertOne(value, { session });
+      delNamespace().then(() => {
+        logger14.info(`Cache cleared for namespace: ${namespace_collection}`);
+      }).catch((err) => {
+        logger14.error(
+          `Failed to clear cache for namespace: ${namespace_collection}`,
+          err
+        );
+      });
+      return res.insertedId;
+    } catch (error) {
+      throw error;
+    }
+  }
+  async function updateScheduleTaskArea(_id, params) {
+    try {
+      _id = new ObjectId8(_id);
+    } catch (error) {
+      throw new BadRequestError17("Invalid area ID format.");
+    }
+    try {
+      const value = MScheduleTaskArea({ ...params, updatedAt: /* @__PURE__ */ new Date() });
+      const res = await collection.updateOne({ _id }, { $set: value });
+      if (res.modifiedCount === 0) {
+        throw new InternalServerError5("Unable to update cleaning area.");
+      }
+      delNamespace().then(() => {
+        logger14.info(`Cache cleared for namespace: ${namespace_collection}`);
+      }).catch((err) => {
+        logger14.error(
+          `Failed to clear cache for namespace: ${namespace_collection}`,
+          err
+        );
+      });
+      return res.modifiedCount;
+    } catch (error) {
+      throw error;
+    }
+  }
+  async function deleteScheduleTaskArea(_id, session) {
+    try {
+      _id = new ObjectId8(_id);
+    } catch (error) {
+      throw new BadRequestError17("Invalid area ID format.");
+    }
+    try {
+      const updateValue = {
+        status: "deleted",
+        updatedAt: /* @__PURE__ */ new Date(),
+        deletedAt: /* @__PURE__ */ new Date()
+      };
+      const res = await collection.updateOne(
+        { _id },
+        { $set: updateValue },
+        { session }
+      );
+      if (res.modifiedCount === 0)
+        throw new InternalServerError5("Unable to delete area.");
+      const cacheKey = makeCacheKey5(namespace_collection, { _id });
+      delCache(cacheKey).then(() => {
+        logger14.info(`Cache deleted for key: ${cacheKey}`);
+      }).catch((err) => {
+        logger14.error(`Failed to delete cache for key: ${cacheKey}`, err);
+      });
+      return res.modifiedCount;
+    } catch (error) {
+      throw error;
+    }
+  }
+  async function getScheduleTaskAreas({
+    page = 1,
+    limit = 10,
+    search = "",
+    sort = {},
+    startDate = "",
+    endDate = "",
+    site = ""
+  }) {
+    page = page > 0 ? page - 1 : 0;
+    let dateFilter = {};
+    try {
+      site = new ObjectId8(site);
+    } catch (error) {
+      throw new BadRequestError17("Invalid site ID format.");
+    }
+    const query = {
+      status: { $ne: "deleted" }
+    };
+    const cacheOptions = {
+      site: site.toString()
+    };
+    sort = Object.keys(sort).length > 0 ? sort : { _id: -1 };
+    cacheOptions.sort = JSON.stringify(sort);
+    if (search) {
+      query.$or = [{ name: { $regex: search, $options: "i" } }];
+      cacheOptions.search = search;
+    }
+    delNamespace().then(() => {
+      logger14.info(`Cache cleared for namespace: ${namespace_collection}`);
+    }).catch((err) => {
+      logger14.error(
+        `Failed to clear cache for namespace: ${namespace_collection}`,
+        err
+      );
+    });
+    const cacheKey = makeCacheKey5(namespace_collection, cacheOptions);
+    const cachedData = await getCache(cacheKey);
+    if (cachedData) {
+      logger14.info(`Cache hit for key: ${cacheKey}`);
+      return cachedData;
+    }
+    if (startDate && endDate) {
+      dateFilter = {
+        createdAt: {
+          $gte: new Date(startDate),
+          $lte: new Date(endDate)
+        }
+      };
+    } else if (startDate) {
+      dateFilter = { createdAt: { $gte: new Date(startDate) } };
+    } else if (endDate) {
+      dateFilter = { createdAt: { $lte: new Date(endDate) } };
+    }
+    try {
+      const items = await collection.aggregate([
+        {
+          $match: {
+            ...dateFilter,
+            ...query
+          }
+        },
+        {
+          $lookup: {
+            from: "sites",
+            localField: "site",
+            foreignField: "_id",
+            pipeline: [{ $project: { name: 1 } }],
+            as: "site"
+          }
+        },
+        {
+          $unwind: {
+            path: "$site",
+            preserveNullAndEmptyArrays: true
+          }
+        },
+        {
+          $lookup: {
+            from: "users",
+            localField: "createdBy",
+            foreignField: "_id",
+            pipeline: [{ $project: { name: 1 } }],
+            as: "createdBy"
+          }
+        },
+        {
+          $unwind: {
+            path: "$createdBy",
+            preserveNullAndEmptyArrays: true
+          }
+        },
+        {
+          $facet: {
+            totalCount: [{ $count: "count" }],
+            items: [
+              { $sort: { createdAt: -1 } },
+              { $skip: page * limit },
+              { $limit: limit }
+            ]
+          }
+        }
+      ]).toArray();
+      const length = await collection.countDocuments(query);
+      const data = paginate5(items, page, limit, length);
+      setCache(cacheKey, data, 15 * 60).then(() => {
+        logger14.info(`Cache set for key: ${cacheKey}`);
+      }).catch((err) => {
+        logger14.error(`Failed to set cache for key: ${cacheKey}`, err);
+      });
+      return data;
+    } catch (error) {
+      throw error;
+    }
+  }
+  async function getScheduleTaskAreaByName(name, site) {
+    try {
+      if (site)
+        site = new ObjectId8(site);
+    } catch (error) {
+      throw new BadRequestError17("Invalid site ID format.");
+    }
+    try {
+      return await collection.findOne({
+        name: { $regex: new RegExp(`^${name}$`, "i") },
+        ...site && { site }
+      });
+    } catch (error) {
+      throw new BadRequestError17("Unable to fetch schedule task area by name.");
+    }
+  }
+  async function getScheduleTaskAreaById(id, site) {
+    try {
+      id = typeof id === "string" ? new ObjectId8(id) : id;
+    } catch (error) {
+      throw new BadRequestError17("Invalid unit ID format.");
+    }
+    try {
+      if (site)
+        site = new ObjectId8(site);
+    } catch (error) {
+      throw new BadRequestError17(
+        "Unable to fetch schedule task area by ID, Invalid site ID format."
+      );
+    }
+    try {
+      return await collection.findOne({ _id: id, ...site && { site } });
+    } catch (error) {
+      throw new BadRequestError17("Unable to fetch schedule task area by id.");
+    }
+  }
+  return {
+    createScheduleTaskArea,
+    updateScheduleTaskArea,
+    deleteScheduleTaskArea,
+    getScheduleTaskAreas,
+    createIndexes,
+    getScheduleTaskAreaByName,
+    getScheduleTaskAreaById
+  };
+}
+
+// src/services/hygiene-schedule-task-area.service.ts
+import {
+  InternalServerError as InternalServerError6
+} from "@iservice365/node-server-utils";
+function useScheduleTaskAreaService() {
+  const {
+    getScheduleTaskAreas: _getAll,
+    createScheduleTaskArea: _create,
+    updateScheduleTaskArea: _updateById,
+    deleteScheduleTaskArea: _deleteById,
+    getScheduleTaskAreaByName: _getScheduleTaskAreaByName,
+    getScheduleTaskAreaById: _getScheduleTaskAreaById
+  } = useScheduleTaskAreaRepository();
+  async function getAll(query) {
+    return await _getAll(query);
+  }
+  async function create(scheduleTaskArea) {
+    const result = await _getScheduleTaskAreaByName(
+      scheduleTaskArea.name,
+      scheduleTaskArea.site
+    );
+    if (result)
+      throw new InternalServerError6(
+        "Schedule Task Area name already exists in this site."
+      );
+    return await _create(scheduleTaskArea);
+  }
+  async function updateById(id, scheduleTaskArea) {
+    const result = await _getScheduleTaskAreaByName(
+      scheduleTaskArea.name,
+      scheduleTaskArea.site
+    );
+    const resultId = result?._id.toString() ?? "";
+    if (result && id != resultId) {
+      throw new InternalServerError6(
+        "Schedule Task Area name already exists in this site."
+      );
+    }
+    return await _updateById(id, scheduleTaskArea);
+  }
+  async function deleteById(id) {
+    return await _deleteById(id);
+  }
+  return {
+    getAll,
+    create,
+    updateById,
+    deleteById
+  };
+}
+
+// src/controllers/hygiene-schedule-task-area.controller.ts
+import { BadRequestError as BadRequestError19, logger as logger16 } from "@iservice365/node-server-utils";
+import Joi10 from "joi";
+function useScheduleTaskAreaController() {
+  const {
+    getAll: _getAll,
+    create: _createScheduleTaskArea,
+    updateById: _updateScheduleTaskArea,
+    deleteById: _deleteById
+  } = useScheduleTaskAreaService();
+  async function getAll(req, res, next) {
+    const query = req.query;
+    const validation = Joi10.object({
+      page: Joi10.number().min(1).optional().allow("", null),
+      limit: Joi10.number().min(1).optional().allow("", null),
+      search: Joi10.string().optional().allow("", null),
+      site: Joi10.string().hex().optional().allow("", null)
+    });
+    const { error } = validation.validate(query);
+    if (error) {
+      next(new BadRequestError19(error.message));
+      return;
+    }
+    const page = parseInt(req.query.page) ?? 1;
+    let limit = parseInt(req.query.limit) ?? 20;
+    limit = isNaN(limit) ? 20 : limit;
+    const sort = req.query.sort ? String(req.query.sort).split(",") : "";
+    const sortOrder = req.query.sortOrder ? String(req.query.sortOrder).split(",") : "";
+    const sortObj = {};
+    if (sort && Array.isArray(sort) && sort.length && sortOrder && Array.isArray(sortOrder) && sortOrder.length) {
+      sort.forEach((field, index) => {
+        sortObj[field] = sortOrder[index] === "desc" ? -1 : 1;
+      });
+    }
+    const site = req.query.site ?? "";
+    const search = req.query.search ?? "";
+    try {
+      const scheduleTaskAreas = await _getAll({
+        page,
+        limit,
+        sort: sortObj,
+        site,
+        search
+      });
+      res.json(scheduleTaskAreas);
+      return;
+    } catch (error2) {
+      next(error2);
+    }
+  }
+  async function createScheduleTaskArea(req, res, next) {
+    const value = req.body;
+    const schema = Joi10.object({
+      name: Joi10.string().required(),
+      site: Joi10.string().hex().optional().allow("", null),
+      createdBy: Joi10.string().hex().optional().allow("", null)
+    });
+    const { error } = schema.validate(value);
+    if (error) {
+      next(new BadRequestError19(error.message));
+      logger16.info(`Controller: ${error.message}`);
+      return;
+    }
+    try {
+      const result = await _createScheduleTaskArea(value);
+      res.status(201).json(result);
+      return;
+    } catch (error2) {
+      next(error2);
+    }
+  }
+  async function updateScheduleTaskArea(req, res, next) {
+    const { name, site, createdBy } = req.body;
+    const id = req.params.id;
+    const schema = Joi10.object({
+      id: Joi10.string().hex().required(),
+      name: Joi10.string().required(),
+      site: Joi10.string().required(),
+      checklist: Joi10.array().optional().items(
+        Joi10.object({
+          _id: Joi10.string().optional().required(),
+          name: Joi10.string().optional().required()
+        })
+      ),
+      createdBy: Joi10.string().hex().optional().allow("", null)
+    });
+    const { error } = schema.validate({ id, name, createdBy, site });
+    if (error) {
+      next(new BadRequestError19(error.message));
+      logger16.info(`Controller: ${error.message}`);
+      return;
+    }
+    try {
+      const result = await _updateScheduleTaskArea(id, {
+        name,
+        createdBy,
+        site
+      });
+      res.json(result);
+      return;
+    } catch (error2) {
+      next(error2);
+    }
+  }
+  async function deleteScheduleTaskArea(req, res, next) {
+    const id = req.params.id;
+    const validation = Joi10.object({
+      id: Joi10.string().hex().required()
+    });
+    const { error } = validation.validate({ id });
+    if (error) {
+      next(new BadRequestError19(error.message));
+      return;
+    }
+    try {
+      const message = await _deleteById(id);
+      res.json(message);
+      return;
+    } catch (error2) {
+      next(error2);
+    }
+  }
+  return {
+    getAll,
+    createScheduleTaskArea,
+    updateScheduleTaskArea,
+    deleteScheduleTaskArea
+  };
+}
+export {
+  MArea,
+  MParentChecklist,
+  MScheduleTaskArea,
+  MToiletLocation,
+  MUnit,
+  areaSchema,
+  parentChecklistSchema,
+  scheduleTaskAreaSchema,
+  toiletLocationSchema,
+  unitSchema,
+  useAreaController,
+  useAreaRepository,
+  useAreaService,
+  useParentCheckilstController,
+  useParentChecklistRepo,
+  useScheduleTaskAreaController,
+  useScheduleTaskAreaRepository,
+  useScheduleTaskAreaService,
+  useToiletLocationController,
+  useToiletLocationRepository,
+  useToiletLocationService,
+  useUnitController,
+  useUnitRepository,
+  useUnitService
+};
 //# sourceMappingURL=index.mjs.map