@7365admin1/module-hygiene 4.21.0 → 4.23.0

package/dist/index.mjs

@@ -17,6 +17,7 @@ import {
   BadRequestError,
   useCache,
   makeCacheKey,
+  paginate,
   logger
 } from "@7365admin1/node-server-utils";
 function useHygieneDashboardRepository() {
@@ -25,72 +26,57 @@ function useHygieneDashboardRepository() {
     throw new InternalServerError("Unable to connect to server.");
   }
   const dashboard_namespace_collection = "hygiene.dashboard";
-  const feedback_namespace_collection = "feedbacks";
   const cleaning_schedule_namespace_collection = "site.cleaning.schedules";
   const area_checklist_namespace_collection = "site.cleaning.schedule.areas";
-  const schedule_task_namespace_collection = "site.schedule-tasks";
   const supply_namespace_collection = "site.supplies";
-  const request_item_namespace_collection = "site.supply.requests";
-  const feedbackCollection = db.collection(feedback_namespace_collection);
+  const work_order_namespace_collection = "work-orders2";
   const areaChecklistCollection = db.collection(
     area_checklist_namespace_collection
   );
-  const scheduleTaskCollection = db.collection(
-    schedule_task_namespace_collection
-  );
   const supplyCollection = db.collection(supply_namespace_collection);
-  const requestItemCollection = db.collection(
-    request_item_namespace_collection
-  );
+  const workOrderCollection = db.collection(work_order_namespace_collection);
+  const attendanceCollection = db.collection("site.attendances");
+  const feedbackCollection = db.collection("feedbacks2");
   const { setCache, getCache } = useCache(dashboard_namespace_collection);
+  const workOrderServiceMap = {
+    security_agency: "Security",
+    cleaning_services: "Cleaning",
+    mechanical_electrical_services: "M&E",
+    landscaping_services: "Landscape",
+    pest_control_services: "Pest Control",
+    pool_maintenance_services: "Pool Maintenance"
+  };
+  function areaChecklistScheduleLookup(site, serviceType, createdAtRange) {
+    return [
+      { $match: { serviceType } },
+      {
+        $lookup: {
+          from: cleaning_schedule_namespace_collection,
+          localField: "schedule",
+          foreignField: "_id",
+          as: "scheduleDoc",
+          pipeline: [
+            {
+              $match: {
+                site,
+                serviceType,
+                createdAt: createdAtRange
+              }
+            }
+          ]
+        }
+      },
+      { $unwind: { path: "$scheduleDoc", preserveNullAndEmptyArrays: false } }
+    ];
+  }
   async function getHygieneDashboard({
     site,
-    feedbackPeriod = "today",
-    commonAreaPeriod = "today",
-    toiletAreaPeriod = "today",
-    scheduleTaskPeriod = "today",
-    supplyPeriod = "today",
-    requestItemPeriod = "today"
+    serviceType,
+    period = "today"
   }) {
-    const countQueries = {
-      feedback: {},
-      commonArea: {},
-      toiletArea: {},
-      scheduleTask: {},
-      supply: {},
-      requestItem: {}
-    };
-    const yesterDayQueries = {
-      feedback: {},
-      commonArea: {},
-      toiletArea: {},
-      scheduleTask: {},
-      supply: {},
-      requestItem: {}
-    };
-    const todayQueries = {
-      feedback: {},
-      commonArea: {},
-      toiletArea: {},
-      scheduleTask: {},
-      supply: {},
-      requestItem: {}
-    };
-    const cacheOptions = {
-      feedbackPeriod,
-      commonAreaPeriod,
-      toiletAreaPeriod,
-      scheduleTaskPeriod,
-      supplyPeriod,
-      requestItemPeriod
-    };
+    const cacheOptions = { serviceType, period };
     try {
       site = new ObjectId(site);
-      Object.keys(countQueries).forEach((key) => {
-        countQueries[key].site = site;
-        yesterDayQueries[key].site = site;
-        todayQueries[key].site = site;
-      });
       cacheOptions.site = site.toString();
     } catch (error) {
       throw new BadRequestError("Invalid site ID format.");
@@ -118,32 +104,28 @@ function useHygieneDashboardRepository() {
       });
       return singaporeMoment.toDate();
     }
-    function applyPeriodToQuery(query, period) {
-      const today = /* @__PURE__ */ new Date();
-      today.setHours(0, 0, 0, 0);
-      if (period === "today") {
-        query.createdAt = {
-          $gte: today,
-          $lte: formatEndDate(today)
-        };
-      } else if (period === "thisWeek" || period === "thisMonth") {
-        const filterDate = period === "thisWeek" ? 7 : 30;
-        const filterStartDate = /* @__PURE__ */ new Date();
-        filterStartDate.setDate(today.getDate() - filterDate);
-        filterStartDate.setHours(0, 0, 0, 0);
-        query.createdAt = {
-          $gte: filterStartDate,
-          $lte: formatEndDate(/* @__PURE__ */ new Date())
-        };
+    function getDateRange(p) {
+      const start = /* @__PURE__ */ new Date();
+      start.setHours(0, 0, 0, 0);
+      if (p === "today") {
+        return { $gte: start, $lte: formatEndDate(start) };
       }
-    }
+      const days = p === "thisWeek" ? 7 : 30;
+      const rangeStart = /* @__PURE__ */ new Date();
+      rangeStart.setDate(start.getDate() - days);
+      rangeStart.setHours(0, 0, 0, 0);
+      return { $gte: rangeStart, $lte: formatEndDate(/* @__PURE__ */ new Date()) };
+    }
+    const calculatePercentageChange = (currentCount, previousCount) => {
+      if (previousCount === 0) {
+        return currentCount > 0 ? 100 : 0;
+      }
+      return Math.round(
+        (currentCount - previousCount) / previousCount * 100 * 100
+      ) / 100;
+    };
+    const workOrderService = workOrderServiceMap[serviceType] ?? serviceType;
     try {
-      applyPeriodToQuery(countQueries.feedback, feedbackPeriod);
-      applyPeriodToQuery(countQueries.commonArea, commonAreaPeriod);
-      applyPeriodToQuery(countQueries.toiletArea, toiletAreaPeriod);
-      applyPeriodToQuery(countQueries.scheduleTask, scheduleTaskPeriod);
-      applyPeriodToQuery(countQueries.supply, supplyPeriod);
-      applyPeriodToQuery(countQueries.requestItem, requestItemPeriod);
       const today = /* @__PURE__ */ new Date();
       today.setHours(0, 0, 0, 0);
       const yesterday = /* @__PURE__ */ new Date();
@@ -151,359 +133,566 @@ function useHygieneDashboardRepository() {
       yesterday.setHours(0, 0, 0, 0);
       const yesterdayEnd = new Date(yesterday);
       yesterdayEnd.setHours(23, 59, 59, 999);
-      Object.keys(yesterDayQueries).forEach((key) => {
-        yesterDayQueries[key].createdAt = {
-          $gte: yesterday,
-          $lte: yesterdayEnd
-        };
-      });
-      Object.keys(todayQueries).forEach((key) => {
-        todayQueries[key].createdAt = {
-          $gte: today,
-          $lte: formatEndDate(/* @__PURE__ */ new Date())
-        };
-      });
-      const calculatePercentageChange = (currentCount, previousCount) => {
-        if (previousCount === 0) {
-          return currentCount > 0 ? 100 : 0;
-        }
-        return Math.round(
-          (currentCount - previousCount) / previousCount * 100 * 100
-        ) / 100;
-      };
+      const todayEnd = formatEndDate(/* @__PURE__ */ new Date());
+      const periodRange = getDateRange(period);
       const [
-        feedbackReport,
-        commonAreaChecklistReport,
-        toiletAreaChecklistReport,
-        scheduleTaskReport,
-        supplyReport,
-        requestItemReport
+        workOrderReport,
+        supplyAlertReport,
+        taskCompletedReport,
+        yesterdayWorkOrderReport,
+        todayWorkOrderReport,
+        yesterdayTaskCompletedReport,
+        todayTaskCompletedReport
       ] = await Promise.all([
-        feedbackCollection.aggregate([
+        // 1. Open work orders (period-filtered) with inProgress breakdown
+        workOrderCollection.aggregate([
           {
             $match: {
-              ...countQueries.feedback,
-              category: "cleaning_services",
-              status: "to-do"
+              site,
+              service: workOrderService,
+              createdAt: periodRange,
+              status: { $nin: ["completed"] }
             }
           },
+          {
+            $facet: {
+              total: [{ $count: "count" }],
+              inProgress: [
+                { $match: { status: "in-progress" } },
+                { $count: "count" }
+              ]
+            }
+          }
+        ]).toArray(),
+        // 2. Supply alert — out-of-stock active supplies for site+serviceType
+        supplyCollection.aggregate([
+          { $match: { site, serviceType, qty: 0, status: "active" } },
           { $count: "count" }
         ]).toArray(),
+        // 3. Task completed — area checklists (period-filtered via schedule join)
         areaChecklistCollection.aggregate([
-          { $match: { type: "common" } },
+          ...areaChecklistScheduleLookup(site, serviceType, periodRange),
           {
-            $lookup: {
-              from: cleaning_schedule_namespace_collection,
-              localField: "schedule",
-              foreignField: "_id",
-              as: "scheduleDoc",
-              pipeline: countQueries.commonArea.createdAt ? [
-                {
-                  $match: {
-                    site,
-                    createdAt: countQueries.commonArea.createdAt
-                  }
-                }
-              ] : [{ $match: { site } }]
+            $facet: {
+              total: [{ $count: "count" }],
+              completed: [
+                { $match: { status: "completed" } },
+                { $count: "count" }
+              ],
+              inProgress: [
+                { $match: { status: { $in: ["open", "ongoing"] } } },
+                { $count: "count" }
+              ]
             }
-          },
+          }
+        ]).toArray(),
+        // 4. Yesterday open work orders (for % change)
+        workOrderCollection.aggregate([
           {
-            $unwind: {
-              path: "$scheduleDoc",
-              preserveNullAndEmptyArrays: false
+            $match: {
+              site,
+              service: workOrderService,
+              createdAt: { $gte: yesterday, $lte: yesterdayEnd },
+              status: { $nin: ["completed"] }
             }
           },
           { $count: "count" }
         ]).toArray(),
-        areaChecklistCollection.aggregate([
-          { $match: { type: "toilet" } },
+        // 5. Today open work orders (for % change)
+        workOrderCollection.aggregate([
           {
-            $lookup: {
-              from: cleaning_schedule_namespace_collection,
-              localField: "schedule",
-              foreignField: "_id",
-              as: "scheduleDoc",
-              pipeline: countQueries.toiletArea.createdAt ? [
-                {
-                  $match: {
-                    site,
-                    createdAt: countQueries.toiletArea.createdAt
-                  }
-                }
-              ] : [{ $match: { site } }]
-            }
-          },
-          {
-            $unwind: {
-              path: "$scheduleDoc",
-              preserveNullAndEmptyArrays: false
+            $match: {
+              site,
+              service: workOrderService,
+              createdAt: { $gte: today, $lte: todayEnd },
+              status: { $nin: ["completed"] }
             }
           },
           { $count: "count" }
         ]).toArray(),
-        scheduleTaskCollection.aggregate([
-          { $match: countQueries.scheduleTask },
+        // 6. Yesterday task completed — area checklists (for % change)
+        areaChecklistCollection.aggregate([
+          ...areaChecklistScheduleLookup(site, serviceType, {
+            $gte: yesterday,
+            $lte: yesterdayEnd
+          }),
+          { $match: { status: "completed" } },
           { $count: "count" }
         ]).toArray(),
-        supplyCollection.aggregate([{ $match: countQueries.supply }, { $count: "count" }]).toArray(),
-        requestItemCollection.aggregate([
-          { $match: countQueries.requestItem },
+        // 7. Today task completed — area checklists (for % change)
+        areaChecklistCollection.aggregate([
+          ...areaChecklistScheduleLookup(site, serviceType, {
+            $gte: today,
+            $lte: todayEnd
+          }),
+          { $match: { status: "completed" } },
           { $count: "count" }
         ]).toArray()
       ]);
-      const [
-        yesterdayFeedbackCount,
-        yesterdayCommonAreaChecklistCount,
-        yesterdayToiletAreaChecklistCount,
-        yesterdayScheduledTaskCount,
-        yesterdaySupplyCount,
-        yesterdayRequestItemCount
-      ] = await Promise.all([
-        feedbackCollection.aggregate([
+      const wFacet = workOrderReport[0] ?? { total: [], inProgress: [] };
+      const tFacet = taskCompletedReport[0] ?? {
+        total: [],
+        completed: [],
+        inProgress: []
+      };
+      const result = {
+        openWorkOrder: {
+          count: wFacet.total[0]?.count ?? 0,
+          inProgress: wFacet.inProgress[0]?.count ?? 0,
+          percentage: calculatePercentageChange(
+            todayWorkOrderReport[0]?.count ?? 0,
+            yesterdayWorkOrderReport[0]?.count ?? 0
+          )
+        },
+        supplyAlert: {
+          count: supplyAlertReport[0]?.count ?? 0,
+          percentage: 0
+        },
+        taskCompleted: {
+          completed: tFacet.completed[0]?.count ?? 0,
+          total: tFacet.total[0]?.count ?? 0,
+          inProgress: tFacet.inProgress[0]?.count ?? 0,
+          percentage: calculatePercentageChange(
+            todayTaskCompletedReport[0]?.count ?? 0,
+            yesterdayTaskCompletedReport[0]?.count ?? 0
+          )
+        }
+      };
+      setCache(dashboardCacheKey, result, 15 * 60).then(() => {
+        logger.info(`Cache set for dashboard: ${dashboardCacheKey}`);
+      }).catch((err) => {
+        logger.error(
+          `Failed to set cache for dashboard: ${dashboardCacheKey}`,
+          err
+        );
+      });
+      return result;
+    } catch (error) {
+      throw error;
+    }
+  }
+  async function getWeeklyActivity({
+    site,
+    serviceType
+  }) {
+    const cacheOptions = { serviceType };
+    try {
+      site = new ObjectId(site);
+      cacheOptions.site = site.toString();
+    } catch {
+      throw new BadRequestError("Invalid site ID format.");
+    }
+    const cacheKey = makeCacheKey(
+      `${dashboard_namespace_collection}:weeklyActivity`,
+      cacheOptions
+    );
+    const cachedData = await getCache(cacheKey);
+    if (cachedData) {
+      logger.info(`Cache hit for weeklyActivity: ${cacheKey}`);
+      return cachedData;
+    }
+    const workOrderService = workOrderServiceMap[serviceType] ?? serviceType;
+    const weekStart = moment.tz("Asia/Singapore").startOf("isoWeek").toDate();
+    const weekEnd = moment.tz("Asia/Singapore").endOf("isoWeek").toDate();
+    const weekRange = { $gte: weekStart, $lte: weekEnd };
+    const dayLabels = {
+      1: "Sun",
+      2: "Mon",
+      3: "Tue",
+      4: "Wed",
+      5: "Thu",
+      6: "Fri",
+      7: "Sat"
+    };
+    const dayOrder = [2, 3, 4, 5, 6, 7, 1];
+    try {
+      const [workOrderByDay, taskCompletedByDay] = await Promise.all([
+        workOrderCollection.aggregate([
           {
-            $match: {
-              ...yesterDayQueries.feedback,
-              category: "cleaning_services",
-              status: "to-do"
-            }
+            $match: { site, service: workOrderService, createdAt: weekRange }
           },
-          { $count: "count" }
+          {
+            $group: { _id: { $dayOfWeek: "$createdAt" }, count: { $sum: 1 } }
+          }
         ]).toArray(),
         areaChecklistCollection.aggregate([
-          { $match: { type: "common" } },
+          ...areaChecklistScheduleLookup(site, serviceType, weekRange),
+          { $match: { status: "completed" } },
           {
-            $lookup: {
-              from: cleaning_schedule_namespace_collection,
-              localField: "schedule",
-              foreignField: "_id",
-              as: "scheduleDoc",
-              pipeline: [
-                {
-                  $match: {
-                    site,
-                    createdAt: yesterDayQueries.commonArea.createdAt
-                  }
-                }
-              ]
+            $group: {
+              _id: { $dayOfWeek: "$completedAt" },
+              count: { $sum: 1 }
             }
-          },
+          }
+        ]).toArray()
+      ]);
+      const workOrderMap = new Map(
+        workOrderByDay.map((d) => [d._id, d.count])
+      );
+      const taskMap = new Map(
+        taskCompletedByDay.map((d) => [d._id, d.count])
+      );
+      const result = dayOrder.map((dow) => ({
+        day: dayLabels[dow],
+        workOrder: workOrderMap.get(dow) ?? 0,
+        taskCompleted: taskMap.get(dow) ?? 0
+      }));
+      setCache(cacheKey, result, 15 * 60).then(() => {
+        logger.info(`Cache set for weeklyActivity: ${cacheKey}`);
+      }).catch((err) => {
+        logger.error(
+          `Failed to set cache for weeklyActivity: ${cacheKey}`,
+          err
+        );
+      });
+      return result;
+    } catch (error) {
+      throw error;
+    }
+  }
+  async function getTodayTaskSchedule({
+    site,
+    serviceType,
+    page = 1,
+    limit = 10
+  }) {
+    page = page > 0 ? page - 1 : 0;
+    const cacheOptions = { serviceType, page, limit };
+    try {
+      site = new ObjectId(site);
+      cacheOptions.site = site.toString();
+    } catch {
+      throw new BadRequestError("Invalid site ID format.");
+    }
+    const cacheKey = makeCacheKey(
+      `${dashboard_namespace_collection}:todayTaskSchedule`,
+      cacheOptions
+    );
+    const cachedData = await getCache(cacheKey);
+    if (cachedData) {
+      logger.info(`Cache hit for todayTaskSchedule: ${cacheKey}`);
+      return cachedData;
+    }
+    const todayStart = moment.tz("Asia/Singapore").startOf("day").toDate();
+    const todayEnd = moment.tz("Asia/Singapore").endOf("day").toDate();
+    const todayRange = { $gte: todayStart, $lte: todayEnd };
+    try {
+      const [items, countResult] = await Promise.all([
+        areaChecklistCollection.aggregate([
+          ...areaChecklistScheduleLookup(site, serviceType, todayRange),
           {
-            $unwind: {
-              path: "$scheduleDoc",
-              preserveNullAndEmptyArrays: false
+            $addFields: {
+              _assigneeId: {
+                $reduce: {
+                  input: { $ifNull: ["$checklist", []] },
+                  initialValue: null,
+                  in: {
+                    $cond: {
+                      if: { $ne: ["$$value", null] },
+                      then: "$$value",
+                      else: {
+                        $reduce: {
+                          input: { $ifNull: ["$$this.units", []] },
+                          initialValue: null,
+                          in: {
+                            $cond: {
+                              if: { $ne: ["$$value", null] },
+                              then: "$$value",
+                              else: {
+                                $cond: {
+                                  if: { $gt: ["$$this.completedBy", null] },
+                                  then: "$$this.completedBy",
+                                  else: null
+                                }
+                              }
+                            }
+                          }
+                        }
+                      }
+                    }
+                  }
+                }
+              }
             }
           },
-          { $count: "count" }
-        ]).toArray(),
-        areaChecklistCollection.aggregate([
-          { $match: { type: "toilet" } },
           {
             $lookup: {
-              from: cleaning_schedule_namespace_collection,
-              localField: "schedule",
+              from: "users",
+              localField: "_assigneeId",
               foreignField: "_id",
-              as: "scheduleDoc",
-              pipeline: [
-                {
-                  $match: {
-                    site,
-                    createdAt: yesterDayQueries.toiletArea.createdAt
-                  }
-                }
-              ]
+              as: "_assigneeDoc"
             }
           },
+          { $sort: { createdAt: -1, _id: -1 } },
           {
-            $unwind: {
-              path: "$scheduleDoc",
-              preserveNullAndEmptyArrays: false
+            $project: {
+              name: 1,
+              type: 1,
+              status: 1,
+              assigneeName: { $arrayElemAt: ["$_assigneeDoc.name", 0] }
             }
           },
-          { $count: "count" }
+          { $skip: page * limit },
+          { $limit: limit }
         ]).toArray(),
-        scheduleTaskCollection.aggregate([
-          { $match: yesterDayQueries.scheduleTask },
-          { $count: "count" }
-        ]).toArray(),
-        supplyCollection.aggregate([{ $match: yesterDayQueries.supply }, { $count: "count" }]).toArray(),
-        requestItemCollection.aggregate([
-          { $match: yesterDayQueries.requestItem },
+        areaChecklistCollection.aggregate([
+          ...areaChecklistScheduleLookup(site, serviceType, todayRange),
           { $count: "count" }
         ]).toArray()
       ]);
-      const [
-        todayFeedbackCount,
-        todayCommonAreaChecklistCount,
-        todayToiletAreaChecklistCount,
-        todayScheduledTaskCount,
-        todaySupplyCount,
-        todayRequestItemCount
-      ] = await Promise.all([
-        feedbackCollection.aggregate([
+      const length = countResult[0]?.count ?? 0;
+      const data = paginate(items, page, limit, length);
+      setCache(cacheKey, data, 15 * 60).then(() => {
+        logger.info(`Cache set for todayTaskSchedule: ${cacheKey}`);
+      }).catch((err) => {
+        logger.error(
+          `Failed to set cache for todayTaskSchedule: ${cacheKey}`,
+          err
+        );
+      });
+      return data;
+    } catch (error) {
+      throw error;
+    }
+  }
+  async function getStaffAttendance({
+    site,
+    serviceType,
+    page = 1,
+    limit = 10
+  }) {
+    page = page > 0 ? page - 1 : 0;
+    const cacheOptions = { serviceType, page, limit };
+    try {
+      site = new ObjectId(site);
+      cacheOptions.site = site.toString();
+    } catch {
+      throw new BadRequestError("Invalid site ID format.");
+    }
+    const cacheKey = makeCacheKey(
+      `${dashboard_namespace_collection}:staffAttendance`,
+      cacheOptions
+    );
+    const cachedData = await getCache(cacheKey);
+    if (cachedData) {
+      logger.info(`Cache hit for staffAttendance: ${cacheKey}`);
+      return cachedData;
+    }
+    const todayStart = moment.tz("Asia/Singapore").startOf("day").toDate();
+    const todayEnd = moment.tz("Asia/Singapore").endOf("day").toDate();
+    const todayStartStr = todayStart.toISOString();
+    const todayEndStr = todayEnd.toISOString();
+    try {
+      const [items, length] = await Promise.all([
+        attendanceCollection.aggregate([
           {
             $match: {
-              ...todayQueries.feedback,
-              category: "cleaning_services",
-              status: "to-do"
+              site,
+              serviceType,
+              $or: [
+                { createdAt: { $gte: todayStart, $lte: todayEnd } },
+                { createdAt: { $gte: todayStartStr, $lte: todayEndStr } }
+              ]
             }
           },
-          { $count: "count" }
-        ]).toArray(),
-        areaChecklistCollection.aggregate([
-          { $match: { type: "common" } },
           {
             $lookup: {
-              from: cleaning_schedule_namespace_collection,
-              localField: "schedule",
+              from: "users",
+              localField: "user",
               foreignField: "_id",
-              as: "scheduleDoc",
+              as: "_userDoc"
+            }
+          },
+          {
+            $lookup: {
+              from: "members",
+              let: { userId: "$user", siteId: "$site", type: "$serviceType" },
               pipeline: [
                 {
                   $match: {
-                    site,
-                    createdAt: todayQueries.commonArea.createdAt
+                    $expr: {
+                      $and: [
+                        { $eq: ["$user", "$$userId"] },
+                        { $eq: ["$siteId", "$$siteId"] },
+                        { $eq: ["$type", "$$type"] },
+                        { $ne: ["$status", "deleted"] }
+                      ]
+                    }
                   }
                 }
-              ]
+              ],
+              as: "_memberDoc"
             }
           },
           {
             $unwind: {
-              path: "$scheduleDoc",
-              preserveNullAndEmptyArrays: false
+              path: "$_memberDoc",
+              preserveNullAndEmptyArrays: true
             }
           },
-          { $count: "count" }
-        ]).toArray(),
-        areaChecklistCollection.aggregate([
-          { $match: { type: "toilet" } },
           {
             $lookup: {
-              from: cleaning_schedule_namespace_collection,
-              localField: "schedule",
+              from: "roles",
+              localField: "_memberDoc.role",
               foreignField: "_id",
-              as: "scheduleDoc",
-              pipeline: [
-                {
-                  $match: {
-                    site,
-                    createdAt: todayQueries.toiletArea.createdAt
-                  }
-                }
-              ]
+              as: "_roleDoc"
             }
           },
           {
             $unwind: {
-              path: "$scheduleDoc",
-              preserveNullAndEmptyArrays: false
+              path: "$_roleDoc",
+              preserveNullAndEmptyArrays: true
             }
           },
-          { $count: "count" }
+          { $sort: { createdAt: -1, _id: -1 } },
+          {
+            $project: {
+              checkIn: 1,
+              checkOut: 1,
+              createdAt: 1,
+              userName: { $arrayElemAt: ["$_userDoc.name", 0] },
+              userRole: { $ifNull: ["$_roleDoc.name", ""] },
+              totalHours: {
+                $round: [
+                  {
+                    $divide: [
+                      {
+                        $subtract: [
+                          {
+                            $toDate: {
+                              $ifNull: ["$checkOut.timestamp", "$$NOW"]
+                            }
+                          },
+                          { $toDate: "$checkIn.timestamp" }
+                        ]
+                      },
+                      36e5
+                    ]
+                  },
+                  2
+                ]
+              }
+            }
+          },
+          { $skip: page * limit },
+          { $limit: limit }
         ]).toArray(),
-        scheduleTaskCollection.aggregate([
-          { $match: todayQueries.scheduleTask },
-          { $count: "count" }
+        attendanceCollection.countDocuments({
+          site,
+          serviceType,
+          $or: [
+            { createdAt: { $gte: todayStart, $lte: todayEnd } },
+            { createdAt: { $gte: todayStartStr, $lte: todayEndStr } }
+          ]
+        })
+      ]);
+      const data = paginate(items, page, limit, length);
+      setCache(cacheKey, data, 15 * 60).then(() => {
+        logger.info(`Cache set for staffAttendance: ${cacheKey}`);
+      }).catch((err) => {
+        logger.error(
+          `Failed to set cache for staffAttendance: ${cacheKey}`,
+          err
+        );
+      });
+      return data;
+    } catch (error) {
+      throw error;
+    }
+  }
+  async function getRecentFeedbacks({
+    site,
+    serviceType,
+    page = 1,
+    limit = 10
+  }) {
+    page = page > 0 ? page - 1 : 0;
+    const cacheOptions = { serviceType, page, limit };
+    try {
+      site = new ObjectId(site);
+      cacheOptions.site = site.toString();
+    } catch {
+      throw new BadRequestError("Invalid site ID format.");
+    }
+    const cacheKey = makeCacheKey(
+      `${dashboard_namespace_collection}:recentFeedbacks`,
+      cacheOptions
+    );
+    const cachedData = await getCache(cacheKey);
+    if (cachedData) {
+      logger.info(`Cache hit for recentFeedbacks: ${cacheKey}`);
+      return cachedData;
+    }
+    const workOrderService = workOrderServiceMap[serviceType] ?? serviceType;
+    try {
+      const [items, length] = await Promise.all([
+        feedbackCollection.aggregate([
+          { $match: { site, service: workOrderService } },
+          { $sort: { createdAt: -1, _id: -1 } },
+          {
+            $lookup: {
+              from: "users",
+              localField: "createdBy",
+              foreignField: "_id",
+              as: "_createdByDoc"
+            }
+          },
+          {
+            $project: {
+              description: 1,
+              subject: 1,
+              app: 1,
+              status: 1,
+              createdAt: 1,
+              createdByName: { $arrayElemAt: ["$_createdByDoc.name", 0] }
+            }
+          },
+          { $skip: page * limit },
+          { $limit: limit }
         ]).toArray(),
-        supplyCollection.aggregate([{ $match: todayQueries.supply }, { $count: "count" }]).toArray(),
-        requestItemCollection.aggregate([
-          { $match: todayQueries.requestItem },
-          { $count: "count" }
-        ]).toArray()
+        feedbackCollection.countDocuments({ site, service: workOrderService })
       ]);
-      const resultYesterday = {
-        feedbackCount: yesterdayFeedbackCount[0]?.count || 0,
-        commonAreaChecklistCount: yesterdayCommonAreaChecklistCount[0]?.count || 0,
-        toiletAreaChecklistCount: yesterdayToiletAreaChecklistCount[0]?.count || 0,
-        scheduleTaskCount: yesterdayScheduledTaskCount[0]?.count || 0,
-        supplyCount: yesterdaySupplyCount[0]?.count || 0,
-        requestItemCount: yesterdayRequestItemCount[0]?.count || 0
-      };
-      const resultToday = {
-        feedbackCount: todayFeedbackCount[0]?.count || 0,
-        commonAreaChecklistCount: todayCommonAreaChecklistCount[0]?.count || 0,
-        toiletAreaChecklistCount: todayToiletAreaChecklistCount[0]?.count || 0,
-        scheduleTaskCount: todayScheduledTaskCount[0]?.count || 0,
-        supplyCount: todaySupplyCount[0]?.count || 0,
-        requestItemCount: todayRequestItemCount[0]?.count || 0
-      };
-      const result = {
-        feedback: {
-          count: feedbackReport[0]?.count || 0,
-          percentage: calculatePercentageChange(
-            resultToday.feedbackCount,
-            resultYesterday.feedbackCount
-          )
-        },
-        commonAreaChecklist: {
-          count: commonAreaChecklistReport[0]?.count || 0,
-          percentage: calculatePercentageChange(
-            resultToday.commonAreaChecklistCount,
-            resultYesterday.commonAreaChecklistCount
-          )
-        },
-        toiletAreaChecklist: {
-          count: toiletAreaChecklistReport[0]?.count || 0,
-          percentage: calculatePercentageChange(
-            resultToday.toiletAreaChecklistCount,
-            resultYesterday.toiletAreaChecklistCount
-          )
-        },
-        scheduleTask: {
-          count: scheduleTaskReport[0]?.count || 0,
-          percentage: calculatePercentageChange(
-            resultToday.scheduleTaskCount,
-            resultYesterday.scheduleTaskCount
-          )
-        },
-        supply: {
-          count: supplyReport[0]?.count || 0,
-          percentage: calculatePercentageChange(
-            resultToday.supplyCount,
-            resultYesterday.supplyCount
-          )
-        },
-        requestItem: {
-          count: requestItemReport[0]?.count || 0,
-          percentage: calculatePercentageChange(
-            resultToday.requestItemCount,
-            resultYesterday.requestItemCount
-          )
-        }
-      };
-      setCache(dashboardCacheKey, result, 15 * 60).then(() => {
-        logger.info(`Cache set for dashboard: ${dashboardCacheKey}`);
+      const data = paginate(items, page, limit, length);
+      setCache(cacheKey, data, 15 * 60).then(() => {
+        logger.info(`Cache set for recentFeedbacks: ${cacheKey}`);
       }).catch((err) => {
         logger.error(
-          `Failed to set cache for dashboard: ${dashboardCacheKey}`,
+          `Failed to set cache for recentFeedbacks: ${cacheKey}`,
           err
         );
       });
-      return result;
+      return data;
     } catch (error) {
       throw error;
     }
   }
   return {
-    getHygieneDashboard
+    getHygieneDashboard,
+    getWeeklyActivity,
+    getTodayTaskSchedule,
+    getStaffAttendance,
+    getRecentFeedbacks
   };
 }
 
 // src/controllers/hygiene-dashboard.controller.ts
 import Joi from "joi";
 import { BadRequestError as BadRequestError2, logger as logger2 } from "@7365admin1/node-server-utils";
+import { AppServiceType } from "@7365admin1/core";
 function useHygieneDashboardController() {
-  const { getHygieneDashboard: _getHygieneDashboard } = useHygieneDashboardRepository();
+  const {
+    getHygieneDashboard: _getHygieneDashboard,
+    getWeeklyActivity: _getWeeklyActivity,
+    getTodayTaskSchedule: _getTodayTaskSchedule,
+    getStaffAttendance: _getStaffAttendance,
+    getRecentFeedbacks: _getRecentFeedbacks
+  } = useHygieneDashboardRepository();
   async function getHygieneDashboard(req, res, next) {
     const query = { ...req.query, ...req.params };
     const validation = Joi.object({
       site: Joi.string().hex().required(),
-      feedbackPeriod: Joi.string().valid(...allowedPeriods).optional(),
-      commonAreaPeriod: Joi.string().valid(...allowedPeriods).optional(),
-      toiletAreaPeriod: Joi.string().valid(...allowedPeriods).optional(),
-      scheduleTaskPeriod: Joi.string().valid(...allowedPeriods).optional(),
-      supplyPeriod: Joi.string().valid(...allowedPeriods).optional(),
-      requestItemPeriod: Joi.string().valid(...allowedPeriods).optional()
+      serviceType: Joi.string().valid(...Object.values(AppServiceType)).required(),
+      period: Joi.string().valid(...allowedPeriods).optional()
     });
     const { error } = validation.validate(query);
     if (error) {
@@ -512,21 +701,136 @@ function useHygieneDashboardController() {
       return;
     }
     const site = req.params.site ?? "";
-    const feedbackPeriod = req.query.feedbackPeriod || "today";
-    const commonAreaPeriod = req.query.commonAreaPeriod || "today";
-    const toiletAreaPeriod = req.query.toiletAreaPeriod || "today";
-    const scheduleTaskPeriod = req.query.scheduleTaskPeriod || "today";
-    const supplyPeriod = req.query.supplyPeriod || "today";
-    const requestItemPeriod = req.query.requestItemPeriod || "today";
+    const serviceType = req.params.serviceType;
+    const period = req.query.period || "today";
     try {
       const data = await _getHygieneDashboard({
         site,
-        feedbackPeriod,
-        commonAreaPeriod,
-        toiletAreaPeriod,
-        scheduleTaskPeriod,
-        supplyPeriod,
-        requestItemPeriod
+        period,
+        serviceType
+      });
+      res.json(data);
+      return;
+    } catch (error2) {
+      logger2.log({ level: "error", message: error2.message });
+      next(error2);
+      return;
+    }
+  }
+  async function getWeeklyActivity(req, res, next) {
+    const query = { ...req.params };
+    const validation = Joi.object({
+      site: Joi.string().hex().required(),
+      serviceType: Joi.string().valid(...Object.values(AppServiceType)).required()
+    });
+    const { error } = validation.validate(query);
+    if (error) {
+      logger2.log({ level: "error", message: error.message });
+      next(new BadRequestError2(error.message));
+      return;
+    }
+    const site = req.params.site;
+    const serviceType = req.params.serviceType;
+    try {
+      const data = await _getWeeklyActivity({ site, serviceType });
+      res.json(data);
+      return;
+    } catch (error2) {
+      logger2.log({ level: "error", message: error2.message });
+      next(error2);
+      return;
+    }
+  }
+  async function getTodayTaskSchedule(req, res, next) {
+    const query = { ...req.query, ...req.params };
+    const validation = Joi.object({
+      site: Joi.string().hex().required(),
+      serviceType: Joi.string().valid(...Object.values(AppServiceType)).required(),
+      page: Joi.number().min(1).optional().allow("", null),
+      limit: Joi.number().min(1).optional().allow("", null)
+    });
+    const { error } = validation.validate(query);
+    if (error) {
+      logger2.log({ level: "error", message: error.message });
+      next(new BadRequestError2(error.message));
+      return;
+    }
+    const site = req.params.site;
+    const serviceType = req.params.serviceType;
+    const page = parseInt(req.query.page) ?? 1;
+    const limit = parseInt(req.query.limit) ?? 10;
+    try {
+      const data = await _getTodayTaskSchedule({
+        site,
+        serviceType,
+        page,
+        limit
+      });
+      res.json(data);
+      return;
+    } catch (error2) {
+      logger2.log({ level: "error", message: error2.message });
+      next(error2);
+      return;
+    }
+  }
+  async function getStaffAttendance(req, res, next) {
+    const query = { ...req.query, ...req.params };
+    const validation = Joi.object({
+      site: Joi.string().hex().required(),
+      serviceType: Joi.string().valid(...Object.values(AppServiceType)).required(),
+      page: Joi.number().min(1).optional().allow("", null),
+      limit: Joi.number().min(1).optional().allow("", null)
+    });
+    const { error } = validation.validate(query);
+    if (error) {
+      logger2.log({ level: "error", message: error.message });
+      next(new BadRequestError2(error.message));
+      return;
+    }
+    const site = req.params.site;
+    const serviceType = req.params.serviceType;
+    const page = parseInt(req.query.page) ?? 1;
+    const limit = parseInt(req.query.limit) ?? 10;
+    try {
+      const data = await _getStaffAttendance({
+        site,
+        serviceType,
+        page,
+        limit
+      });
+      res.json(data);
+      return;
+    } catch (error2) {
+      logger2.log({ level: "error", message: error2.message });
+      next(error2);
+      return;
+    }
+  }
+  async function getRecentFeedbacks(req, res, next) {
+    const query = { ...req.query, ...req.params };
+    const validation = Joi.object({
+      site: Joi.string().hex().required(),
+      serviceType: Joi.string().valid(...Object.values(AppServiceType)).required(),
+      page: Joi.number().min(1).optional().allow("", null),
+      limit: Joi.number().min(1).optional().allow("", null)
+    });
+    const { error } = validation.validate(query);
+    if (error) {
+      logger2.log({ level: "error", message: error.message });
+      next(new BadRequestError2(error.message));
+      return;
+    }
+    const site = req.params.site;
+    const serviceType = req.params.serviceType;
+    const page = parseInt(req.query.page) ?? 1;
+    const limit = parseInt(req.query.limit) ?? 10;
+    try {
+      const data = await _getRecentFeedbacks({
+        site,
+        serviceType,
+        page,
+        limit
       });
       res.json(data);
       return;
@@ -537,7 +841,11 @@ function useHygieneDashboardController() {
     }
   }
   return {
-    getHygieneDashboard
+    getHygieneDashboard,
+    getWeeklyActivity,
+    getTodayTaskSchedule,
+    getStaffAttendance,
+    getRecentFeedbacks
   };
 }
 
@@ -545,10 +853,10 @@ function useHygieneDashboardController() {
 import Joi2 from "joi";
 import { ObjectId as ObjectId2 } from "mongodb";
 import { BadRequestError as BadRequestError3, logger as logger3 } from "@7365admin1/node-server-utils";
-import { AppServiceType } from "@7365admin1/core";
+import { AppServiceType as AppServiceType2 } from "@7365admin1/core";
 var areaSchema = Joi2.object({
   site: Joi2.string().hex().required(),
-  serviceType: Joi2.string().valid(...Object.values(AppServiceType)).required(),
+  serviceType: Joi2.string().valid(...Object.values(AppServiceType2)).required(),
   name: Joi2.string().required(),
   type: Joi2.string().valid(...allowedTypes).required(),
   set: Joi2.number().min(0).optional(),
@@ -605,7 +913,7 @@ import { ObjectId as ObjectId3 } from "mongodb";
 import {
   useAtlas as useAtlas2,
   InternalServerError as InternalServerError2,
-  paginate,
+  paginate as paginate2,
   BadRequestError as BadRequestError4,
   useCache as useCache2,
   logger as logger4,
@@ -740,7 +1048,7 @@ function useAreaRepo() {
         { $limit: limit }
       ]).toArray();
       const length = await collection.countDocuments(query);
-      const data = paginate(items, page, limit, length);
+      const data = paginate2(items, page, limit, length);
       setCache(cacheKey, data, 15 * 60).then(() => {
         logger4.info(`Cache set for key: ${cacheKey}`);
       }).catch((err) => {
@@ -1062,7 +1370,7 @@ import { ObjectId as ObjectId5 } from "mongodb";
 import {
   useAtlas as useAtlas3,
   InternalServerError as InternalServerError3,
-  paginate as paginate2,
+  paginate as paginate3,
   BadRequestError as BadRequestError6,
   useCache as useCache3,
   logger as logger7,
@@ -1073,10 +1381,10 @@ import {
 import Joi3 from "joi";
 import { ObjectId as ObjectId4 } from "mongodb";
 import { BadRequestError as BadRequestError5, logger as logger6 } from "@7365admin1/node-server-utils";
-import { AppServiceType as AppServiceType2 } from "@7365admin1/core";
+import { AppServiceType as AppServiceType3 } from "@7365admin1/core";
 var unitSchema = Joi3.object({
   site: Joi3.string().hex().required(),
-  serviceType: Joi3.string().valid(...Object.values(AppServiceType2)).required(),
+  serviceType: Joi3.string().valid(...Object.values(AppServiceType3)).required(),
   name: Joi3.string().required()
 });
 function MUnit(value) {
@@ -1208,7 +1516,7 @@ function useUnitRepository() {
         { $limit: limit }
       ]).toArray();
       const length = await collection.countDocuments(query);
-      const data = paginate2(items, page, limit, length);
+      const data = paginate3(items, page, limit, length);
       setCache(cacheKey, data, 15 * 60).then(() => {
         logger7.info(`Cache set for key: ${cacheKey}`);
       }).catch((err) => {
@@ -1497,7 +1805,7 @@ function useAreaService() {
 // src/controllers/hygiene-area.controller.ts
 import Joi4 from "joi";
 import { BadRequestError as BadRequestError8, logger as logger9 } from "@7365admin1/node-server-utils";
-import { AppServiceType as AppServiceType3 } from "@7365admin1/core";
+import { AppServiceType as AppServiceType4 } from "@7365admin1/core";
 
 // src/utils/convert-excel.util.ts
 import { Readable } from "stream";
@@ -1562,7 +1870,7 @@ function useAreaController() {
       search: Joi4.string().optional().allow("", null),
       type: Joi4.string().valid("all", ...allowedTypes).optional().allow("", null),
       site: Joi4.string().hex().required(),
-      serviceType: Joi4.string().valid(...Object.values(AppServiceType3)).required()
+      serviceType: Joi4.string().valid(...Object.values(AppServiceType4)).required()
     });
     const { error } = validation.validate(query);
     if (error) {
@@ -1671,7 +1979,7 @@ function useAreaController() {
     const query = { ...req.query, ...req.params };
     const validation = Joi4.object({
       site: Joi4.string().hex().required(),
-      serviceType: Joi4.string().valid(...Object.values(AppServiceType3)).required()
+      serviceType: Joi4.string().valid(...Object.values(AppServiceType4)).required()
     });
     const { error, value } = validation.validate(query);
     if (error) {
@@ -1694,7 +2002,7 @@ function useAreaController() {
     const query = { ...req.query, ...req.params };
     const validation = Joi4.object({
       site: Joi4.string().hex().required(),
-      serviceType: Joi4.string().valid(...Object.values(AppServiceType3)).required()
+      serviceType: Joi4.string().valid(...Object.values(AppServiceType4)).required()
     });
     const { error, value } = validation.validate(query);
     if (error) {
@@ -1977,7 +2285,7 @@ function useUnitService() {
 // src/controllers/hygiene-unit.controller.ts
 import Joi5 from "joi";
 import { BadRequestError as BadRequestError10, logger as logger12 } from "@7365admin1/node-server-utils";
-import { AppServiceType as AppServiceType4 } from "@7365admin1/core";
+import { AppServiceType as AppServiceType5 } from "@7365admin1/core";
 function useUnitController() {
   const { createUnit: _createUnit, getUnits: _getUnits } = useUnitRepository();
   const {
@@ -2011,7 +2319,7 @@ function useUnitController() {
       limit: Joi5.number().min(1).optional().allow("", null),
       search: Joi5.string().optional().allow("", null),
       site: Joi5.string().hex().required(),
-      serviceType: Joi5.string().valid(...Object.values(AppServiceType4)).required()
+      serviceType: Joi5.string().valid(...Object.values(AppServiceType5)).required()
     });
     const { error } = validation.validate(query);
     if (error) {
@@ -2092,7 +2400,7 @@ function useUnitController() {
     const query = { ...req.query, ...req.params };
     const validation = Joi5.object({
       site: Joi5.string().hex().required(),
-      serviceType: Joi5.string().valid(...Object.values(AppServiceType4)).required()
+      serviceType: Joi5.string().valid(...Object.values(AppServiceType5)).required()
     });
     const { error, value } = validation.validate(query);
     if (error) {
@@ -2115,7 +2423,7 @@ function useUnitController() {
     const query = { ...req.query, ...req.params };
     const validation = Joi5.object({
       site: Joi5.string().hex().required(),
-      serviceType: Joi5.string().valid(...Object.values(AppServiceType4)).required()
+      serviceType: Joi5.string().valid(...Object.values(AppServiceType5)).required()
     });
     const { error, value } = validation.validate(query);
     if (error) {
@@ -2161,11 +2469,11 @@ function useUnitController() {
 import Joi6 from "joi";
 import { ObjectId as ObjectId6 } from "mongodb";
 import { BadRequestError as BadRequestError11, logger as logger13 } from "@7365admin1/node-server-utils";
-import { AppServiceType as AppServiceType5 } from "@7365admin1/core";
+import { AppServiceType as AppServiceType6 } from "@7365admin1/core";
 var parentChecklistSchema = Joi6.object({
   createdAt: Joi6.alternatives().try(Joi6.date(), Joi6.string()).optional().allow("", null),
   site: Joi6.string().hex().required(),
-  serviceType: Joi6.string().valid(...Object.values(AppServiceType5)).required()
+  serviceType: Joi6.string().valid(...Object.values(AppServiceType6)).required()
 });
 function MParentChecklist(value) {
   const { error } = parentChecklistSchema.validate(value);
@@ -2191,16 +2499,17 @@ function MParentChecklist(value) {
 
 // src/repositories/hygiene-parent-checklist.repository.ts
 import { ObjectId as ObjectId7 } from "mongodb";
+import moment2 from "moment-timezone";
 import {
   useAtlas as useAtlas5,
   InternalServerError as InternalServerError4,
-  paginate as paginate3,
+  paginate as paginate4,
   useCache as useCache4,
   logger as logger14,
   makeCacheKey as makeCacheKey4,
   BadRequestError as BadRequestError12
 } from "@7365admin1/node-server-utils";
-import { AppServiceType as AppServiceType6 } from "@7365admin1/core";
+import { AppServiceType as AppServiceType7 } from "@7365admin1/core";
 function useParentChecklistRepo() {
   const db = useAtlas5.getDb();
   if (!db) {
@@ -2228,11 +2537,9 @@ function useParentChecklistRepo() {
   async function createParentChecklist(value, session) {
     try {
       const currentDate = value.createdAt ? new Date(value.createdAt) : /* @__PURE__ */ new Date();
-      const startOfDay = new Date(currentDate);
-      startOfDay.setUTCHours(0, 0, 0, 0);
-      const endOfDay = new Date(currentDate);
-      endOfDay.setUTCHours(23, 59, 59, 999);
-      const allServiceTypes = Object.values(AppServiceType6);
+      const startOfDay = moment2(currentDate).tz("Asia/Singapore").startOf("day").toDate();
+      const endOfDay = moment2(currentDate).tz("Asia/Singapore").endOf("day").toDate();
+      const allServiceTypes = Object.values(AppServiceType7);
       const dateStr = currentDate.toISOString().split("T")[0];
       if (value.site) {
         let siteObjectId;
@@ -2456,7 +2763,7 @@ function useParentChecklistRepo() {
       );
       const items = await collection.aggregate(pipeline).toArray();
       const length = await collection.countDocuments(query);
-      const data = paginate3(items, page, limit, length);
+      const data = paginate4(items, page, limit, length);
       setCache(cacheKey, data, 15 * 60).then(() => {
         logger14.info(`Cache set for key: ${cacheKey}`);
       }).catch((err) => {
@@ -2582,11 +2889,8 @@ function useParentChecklistRepo() {
     }
   }
   async function getTodayParentChecklists() {
-    const now = /* @__PURE__ */ new Date();
-    const start = new Date(now);
-    start.setUTCHours(0, 0, 0, 0);
-    const end = new Date(now);
-    end.setUTCHours(23, 59, 59, 999);
+    const start = moment2().tz("Asia/Singapore").startOf("day").toDate();
+    const end = moment2().tz("Asia/Singapore").endOf("day").toDate();
     try {
       const items = await collection.find(
         { createdAt: { $gte: start, $lte: end } },
@@ -2599,11 +2903,8 @@ function useParentChecklistRepo() {
     }
   }
   async function getTodayParentChecklistsForAreaGen() {
-    const now = /* @__PURE__ */ new Date();
-    const start = new Date(now);
-    start.setUTCHours(0, 0, 0, 0);
-    const end = new Date(now);
-    end.setUTCHours(23, 59, 59, 999);
+    const start = moment2().tz("Asia/Singapore").startOf("day").toDate();
+    const end = moment2().tz("Asia/Singapore").endOf("day").toDate();
     try {
       const items = await collection.find(
         {
@@ -2637,7 +2938,7 @@ function useParentChecklistRepo() {
 // src/controllers/hygiene-parent-checklist.controller.ts
 import Joi7 from "joi";
 import { BadRequestError as BadRequestError13, logger as logger15 } from "@7365admin1/node-server-utils";
-import { AppServiceType as AppServiceType7 } from "@7365admin1/core";
+import { AppServiceType as AppServiceType8 } from "@7365admin1/core";
 function useParentChecklistController() {
   const {
     createParentChecklist: _createParentChecklist,
@@ -2648,7 +2949,7 @@ function useParentChecklistController() {
     const validation = Joi7.object({
       createdAt: Joi7.alternatives().try(Joi7.date(), Joi7.string()).optional().allow("", null),
       site: Joi7.string().hex().required(),
-      serviceType: Joi7.string().valid(...Object.values(AppServiceType7)).optional().allow("", null)
+      serviceType: Joi7.string().valid(...Object.values(AppServiceType8)).optional().allow("", null)
     });
     const { error } = validation.validate(payload);
     if (error) {
@@ -2673,7 +2974,7 @@ function useParentChecklistController() {
       limit: Joi7.number().min(1).optional().allow("", null),
       search: Joi7.string().optional().allow("", null),
       site: Joi7.string().hex().required(),
-      serviceType: Joi7.string().valid(...Object.values(AppServiceType7)).required(),
+      serviceType: Joi7.string().valid(...Object.values(AppServiceType8)).required(),
       startDate: Joi7.alternatives().try(Joi7.date(), Joi7.string()).optional().allow("", null),
       endDate: Joi7.alternatives().try(Joi7.date(), Joi7.string()).optional().allow("", null),
       status: Joi7.string().valid(...allowedStatus, "all").optional().allow("", null)
@@ -2721,11 +3022,11 @@ function useParentChecklistController() {
 import Joi8 from "joi";
 import { ObjectId as ObjectId8 } from "mongodb";
 import { BadRequestError as BadRequestError14, logger as logger16 } from "@7365admin1/node-server-utils";
-import { AppServiceType as AppServiceType8 } from "@7365admin1/core";
+import { AppServiceType as AppServiceType9 } from "@7365admin1/core";
 var allowedChecklistStatus = ["open", "completed", "closed"];
 var areaChecklistSchema = Joi8.object({
   schedule: Joi8.string().hex().required(),
-  serviceType: Joi8.string().valid(...Object.values(AppServiceType8)).required(),
+  serviceType: Joi8.string().valid(...Object.values(AppServiceType9)).required(),
   area: Joi8.string().hex().required(),
   name: Joi8.string().required(),
   type: Joi8.string().valid(...allowedTypes).required(),
@@ -2812,7 +3113,7 @@ import {
   InternalServerError as InternalServerError5,
   logger as logger17,
   makeCacheKey as makeCacheKey5,
-  paginate as paginate4,
+  paginate as paginate5,
   useAtlas as useAtlas6,
   useCache as useCache5
 } from "@7365admin1/node-server-utils";
@@ -3003,7 +3304,7 @@ function useAreaChecklistRepo() {
       ];
       const items = await collection.aggregate(pipeline, { session }).toArray();
       const length = await collection.countDocuments(query, { session });
-      const data = paginate4(items, page, limit, length);
+      const data = paginate5(items, page, limit, length);
       setCache(cacheKey, data, 15 * 60).then(() => {
         logger17.info(`Cache set for key: ${cacheKey}`);
       }).catch((err) => {
@@ -3111,7 +3412,7 @@ function useAreaChecklistRepo() {
       ];
       const items = await collection.aggregate(pipeline).toArray();
       const length = await collection.countDocuments(query);
-      const data = paginate4(items, page, limit, length);
+      const data = paginate5(items, page, limit, length);
       setCache(cacheKey, data, 15 * 60).then(() => {
         logger17.info(`Cache set for key: ${cacheKey}`);
       }).catch((err) => {
@@ -3498,7 +3799,7 @@ function useAreaChecklistRepo() {
         collection.aggregate(countPipeline, { session }).toArray()
       ]);
       const length = countResult.length > 0 ? countResult[0].total : 0;
-      const data = paginate4(items, page, limit, length);
+      const data = paginate5(items, page, limit, length);
       setCache(cacheKey, data, 15 * 60).then(() => {
         logger17.info(`Cache set for key: ${cacheKey}`);
       }).catch((err) => {
@@ -4177,7 +4478,7 @@ import {
   InternalServerError as InternalServerError7,
   logger as logger20
 } from "@7365admin1/node-server-utils";
-import { AppServiceType as AppServiceType9 } from "@7365admin1/core";
+import { AppServiceType as AppServiceType10 } from "@7365admin1/core";
 
 // src/services/hygiene-checklist-pdf.service.ts
 import { launch } from "puppeteer";
@@ -4444,7 +4745,7 @@ function useAreaChecklistController() {
       type: Joi9.string().valid(...allowedTypes, "all").optional().allow("", null),
       status: Joi9.string().valid(...allowedStatus, "all").optional().allow("", null),
       schedule: Joi9.string().hex().required(),
-      serviceType: Joi9.string().valid(...Object.values(AppServiceType9)).required()
+      serviceType: Joi9.string().valid(...Object.values(AppServiceType10)).required()
     });
     const { error } = validation.validate(query);
     if (error) {
@@ -4544,7 +4845,7 @@ function useAreaChecklistController() {
       page: Joi9.number().min(1).optional().allow("", null),
       limit: Joi9.number().min(1).optional().allow("", null),
       search: Joi9.string().optional().allow("", null),
-      serviceType: Joi9.string().valid(...Object.values(AppServiceType9)).required(),
+      serviceType: Joi9.string().valid(...Object.values(AppServiceType10)).required(),
       id: Joi9.string().hex().required()
     });
     const { error } = validation.validate(query);
@@ -4673,12 +4974,13 @@ function useAreaChecklistController() {
 import Joi10 from "joi";
 import { ObjectId as ObjectId12 } from "mongodb";
 import { BadRequestError as BadRequestError17, logger as logger21 } from "@7365admin1/node-server-utils";
-import { AppServiceType as AppServiceType10 } from "@7365admin1/core";
+import { AppServiceType as AppServiceType11 } from "@7365admin1/core";
 var supplySchema = Joi10.object({
   site: Joi10.string().hex().required(),
-  serviceType: Joi10.string().valid(...Object.values(AppServiceType10)).required(),
+  serviceType: Joi10.string().valid(...Object.values(AppServiceType11)).required(),
   name: Joi10.string().required(),
-  unitOfMeasurement: Joi10.string().required()
+  unitOfMeasurement: Joi10.string().required(),
+  attachment: Joi10.string().allow(null, "").optional()
 });
 function MSupply(value) {
   const { error } = supplySchema.validate(value);
@@ -4699,6 +5001,7 @@ function MSupply(value) {
     name: value.name,
     unitOfMeasurement: value.unitOfMeasurement,
     qty: 0,
+    attachment: value.attachment,
     status: "active",
     createdAt: (/* @__PURE__ */ new Date()).toISOString(),
     updatedAt: "",
@@ -4711,7 +5014,7 @@ import { ObjectId as ObjectId13 } from "mongodb";
 import {
   useAtlas as useAtlas9,
   InternalServerError as InternalServerError8,
-  paginate as paginate5,
+  paginate as paginate6,
   BadRequestError as BadRequestError18,
   useCache as useCache6,
   logger as logger22,
@@ -4819,6 +5122,7 @@ function useSupplyRepository() {
         { $match: query },
         {
           $project: {
+            attachment: 1,
             name: 1,
             qty: 1,
             status: 1
@@ -4829,7 +5133,7 @@ function useSupplyRepository() {
         { $limit: limit }
       ]).toArray();
       const length = await collection.countDocuments(query);
-      const data = paginate5(items, page, limit, length);
+      const data = paginate6(items, page, limit, length);
       setCache(cacheKey, data, 15 * 60).then(() => {
         logger22.info(`Cache set for key: ${cacheKey}`);
       }).catch((err) => {
@@ -4867,6 +5171,7 @@ function useSupplyRepository() {
         { $match: query },
         {
           $project: {
+            attachment: 1,
             name: 1,
             unitOfMeasurement: 1,
             qty: 1
@@ -4967,7 +5272,7 @@ function useSupplyRepository() {
 // src/controllers/hygiene-supply.controller.ts
 import Joi11 from "joi";
 import { BadRequestError as BadRequestError19, logger as logger23 } from "@7365admin1/node-server-utils";
-import { AppServiceType as AppServiceType11 } from "@7365admin1/core";
+import { AppServiceType as AppServiceType12 } from "@7365admin1/core";
 function useSupplyController() {
   const {
     createSupply: _createSupply,
@@ -5001,7 +5306,7 @@ function useSupplyController() {
       limit: Joi11.number().min(1).optional().allow("", null),
       search: Joi11.string().optional().allow("", null),
       site: Joi11.string().hex().required(),
-      serviceType: Joi11.string().valid(...Object.values(AppServiceType11)).required()
+      serviceType: Joi11.string().valid(...Object.values(AppServiceType12)).required()
     });
     const { error } = validation.validate(query);
     if (error) {
@@ -5055,7 +5360,8 @@ function useSupplyController() {
       id: Joi11.string().hex().required(),
       name: Joi11.string().optional().allow("", null),
       unitOfMeasurement: Joi11.string().optional().allow("", null),
-      qty: Joi11.number().min(0).optional().allow("", null)
+      qty: Joi11.number().min(0).optional().allow("", null),
+      attachment: Joi11.string().optional().allow("", null)
     });
     const { error } = validation.validate(payload);
     if (error) {
@@ -5106,10 +5412,10 @@ function useSupplyController() {
 import Joi12 from "joi";
 import { ObjectId as ObjectId14 } from "mongodb";
 import { BadRequestError as BadRequestError20, logger as logger24 } from "@7365admin1/node-server-utils";
-import { AppServiceType as AppServiceType12 } from "@7365admin1/core";
+import { AppServiceType as AppServiceType13 } from "@7365admin1/core";
 var stockSchema = Joi12.object({
   site: Joi12.string().hex().required(),
-  serviceType: Joi12.string().valid(...Object.values(AppServiceType12)).required(),
+  serviceType: Joi12.string().valid(...Object.values(AppServiceType13)).required(),
   supply: Joi12.string().hex().required(),
   in: Joi12.number().min(0).optional(),
   out: Joi12.number().min(0).optional(),
@@ -5160,7 +5466,7 @@ import {
   useCache as useCache7,
   logger as logger25,
   makeCacheKey as makeCacheKey7,
-  paginate as paginate6
+  paginate as paginate7
 } from "@7365admin1/node-server-utils";
 function useStockRepository() {
   const db = useAtlas10.getDb();
@@ -5268,7 +5574,7 @@ function useStockRepository() {
         { $limit: limit }
       ]).toArray();
       const length = await collection.countDocuments(query);
-      const data = paginate6(items, page, limit, length);
+      const data = paginate7(items, page, limit, length);
       setCache(cacheKey, data, 15 * 60).then(() => {
         logger25.info(`Cache set for key: ${cacheKey}`);
       }).catch((err) => {
@@ -5343,7 +5649,7 @@ function useStockService() {
 // src/controllers/hygiene-stock.controller.ts
 import Joi13 from "joi";
 import { BadRequestError as BadRequestError23, logger as logger26 } from "@7365admin1/node-server-utils";
-import { AppServiceType as AppServiceType13 } from "@7365admin1/core";
+import { AppServiceType as AppServiceType14 } from "@7365admin1/core";
 function useStockController() {
   const { getStocksBySupplyId: _getStocksBySupplyId } = useStockRepository();
   const { createStock: _createStock } = useStockService();
@@ -5351,7 +5657,7 @@ function useStockController() {
     const payload = { ...req.body, ...req.params };
     const validation = Joi13.object({
       site: Joi13.string().hex().required(),
-      serviceType: Joi13.string().valid(...Object.values(AppServiceType13)).required(),
+      serviceType: Joi13.string().valid(...Object.values(AppServiceType14)).required(),
       supply: Joi13.string().hex().required(),
       qty: Joi13.number().min(0).required(),
       remarks: Joi13.string().optional().allow("", null)
@@ -5379,7 +5685,7 @@ function useStockController() {
       limit: Joi13.number().min(1).optional().allow("", null),
       search: Joi13.string().optional().allow("", null),
       site: Joi13.string().hex().required(),
-      serviceType: Joi13.string().valid(...Object.values(AppServiceType13)).required(),
+      serviceType: Joi13.string().valid(...Object.values(AppServiceType14)).required(),
       supply: Joi13.string().hex().required()
     });
     const { error } = validation.validate(query);
@@ -5421,11 +5727,11 @@ function useStockController() {
 import Joi14 from "joi";
 import { ObjectId as ObjectId16 } from "mongodb";
 import { BadRequestError as BadRequestError24, logger as logger27 } from "@7365admin1/node-server-utils";
-import { AppServiceType as AppServiceType14 } from "@7365admin1/core";
+import { AppServiceType as AppServiceType15 } from "@7365admin1/core";
 var allowedCheckOutItemStatus = ["pending", "completed"];
 var checkOutItemSchema = Joi14.object({
   site: Joi14.string().hex().required(),
-  serviceType: Joi14.string().valid(...Object.values(AppServiceType14)).required(),
+  serviceType: Joi14.string().valid(...Object.values(AppServiceType15)).required(),
   supply: Joi14.string().hex().required(),
   supplyName: Joi14.string().required(),
   qty: Joi14.number().min(0).required(),
@@ -5477,7 +5783,7 @@ import {
   useCache as useCache8,
   logger as logger28,
   makeCacheKey as makeCacheKey8,
-  paginate as paginate7,
+  paginate as paginate8,
   BadRequestError as BadRequestError25,
   NotFoundError as NotFoundError6
 } from "@7365admin1/node-server-utils";
@@ -5636,7 +5942,7 @@ function useCheckOutItemRepository() {
         { $limit: limit }
       ]).toArray();
       const length = await collection.countDocuments(query);
-      const data = paginate7(items, page, limit, length);
+      const data = paginate8(items, page, limit, length);
       setCache(cacheKey, data, 15 * 60).then(() => {
         logger28.info(`Cache set for key: ${cacheKey}`);
       }).catch((err) => {
@@ -5859,7 +6165,7 @@ function useCheckOutItemService() {
 // src/controllers/hygiene-checkout-item.controller.ts
 import Joi15 from "joi";
 import { BadRequestError as BadRequestError27, logger as logger29 } from "@7365admin1/node-server-utils";
-import { AppServiceType as AppServiceType15 } from "@7365admin1/core";
+import { AppServiceType as AppServiceType16 } from "@7365admin1/core";
 function useCheckOutItemController() {
   const {
     getCheckOutItems: _getCheckOutItems,
@@ -5882,7 +6188,7 @@ function useCheckOutItemController() {
     };
     const validation = Joi15.object({
       site: Joi15.string().hex().required(),
-      serviceType: Joi15.string().valid(...Object.values(AppServiceType15)).required(),
+      serviceType: Joi15.string().valid(...Object.values(AppServiceType16)).required(),
       supply: Joi15.string().hex().required(),
       qty: Joi15.number().min(0).required(),
       attachment: Joi15.array().items(Joi15.string()).optional().allow(null),
@@ -5917,7 +6223,7 @@ function useCheckOutItemController() {
     };
     const validation = Joi15.object({
       site: Joi15.string().hex().required(),
-      serviceType: Joi15.string().valid(...Object.values(AppServiceType15)).required(),
+      serviceType: Joi15.string().valid(...Object.values(AppServiceType16)).required(),
       createdBy: Joi15.string().hex().required(),
       items: Joi15.array().items(
         Joi15.object({
@@ -5950,7 +6256,7 @@ function useCheckOutItemController() {
       limit: Joi15.number().min(1).optional().allow("", null),
       search: Joi15.string().optional().allow("", null),
       site: Joi15.string().hex().required(),
-      serviceType: Joi15.string().valid(...Object.values(AppServiceType15)).required()
+      serviceType: Joi15.string().valid(...Object.values(AppServiceType16)).required()
     });
     const { error } = validation.validate(query);
     if (error) {
@@ -6008,12 +6314,12 @@ function useCheckOutItemController() {
 
 // src/models/hygiene-schedule-task.model.ts
 import { BadRequestError as BadRequestError28, logger as logger30 } from "@7365admin1/node-server-utils";
-import { AppServiceType as AppServiceType16 } from "@7365admin1/core";
+import { AppServiceType as AppServiceType17 } from "@7365admin1/core";
 import Joi16 from "joi";
 import { ObjectId as ObjectId18 } from "mongodb";
 var scheduleTaskSchema = Joi16.object({
   site: Joi16.string().hex().required(),
-  serviceType: Joi16.string().valid(...Object.values(AppServiceType16)).required(),
+  serviceType: Joi16.string().valid(...Object.values(AppServiceType17)).required(),
   title: Joi16.string().required(),
   time: Joi16.string().pattern(/^([0-1]\d|2[0-3]):([0-5]\d)$/).required(),
   dates: Joi16.array().min(1).items(
@@ -6072,7 +6378,7 @@ import { ObjectId as ObjectId19 } from "mongodb";
 import {
   useAtlas as useAtlas14,
   InternalServerError as InternalServerError11,
-  paginate as paginate8,
+  paginate as paginate9,
   BadRequestError as BadRequestError29,
   useCache as useCache9,
   logger as logger31,
@@ -6175,7 +6481,7 @@ function useScheduleTaskRepository() {
         { $limit: limit }
       ]).toArray();
       const length = await collection.countDocuments(query);
-      const data = paginate8(items, page, limit, length);
+      const data = paginate9(items, page, limit, length);
       setCache(cacheKey, data, 15 * 60).then(() => {
         logger31.info(`Cache set for key: ${cacheKey}`);
       }).catch((err) => {
@@ -6628,7 +6934,7 @@ function useScheduleTaskService() {
 // src/controllers/hygiene-schedule-task.controller.ts
 import Joi17 from "joi";
 import { BadRequestError as BadRequestError30, logger as logger33 } from "@7365admin1/node-server-utils";
-import { AppServiceType as AppServiceType17 } from "@7365admin1/core";
+import { AppServiceType as AppServiceType18 } from "@7365admin1/core";
 function useScheduleTaskController() {
   const {
     createScheduleTask: _createScheduleTask,
@@ -6662,7 +6968,7 @@ function useScheduleTaskController() {
       limit: Joi17.number().min(1).optional().allow("", null),
       search: Joi17.string().optional().allow("", null),
       site: Joi17.string().hex().required(),
-      serviceType: Joi17.string().valid(...Object.values(AppServiceType17)).required()
+      serviceType: Joi17.string().valid(...Object.values(AppServiceType18)).required()
     });
     const { error } = validation.validate(query);
     if (error) {