@7365admin1/module-hygiene 4.20.0 → 4.22.0

package/dist/index.js

@@ -102,72 +102,57 @@ function useHygieneDashboardRepository() {
     throw new import_node_server_utils.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 } = (0, import_node_server_utils.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 import_mongodb.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 import_node_server_utils.BadRequestError("Invalid site ID format.");
@@ -195,32 +180,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();
@@ -228,359 +209,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(() => {
+        import_node_server_utils.logger.info(`Cache set for dashboard: ${dashboardCacheKey}`);
+      }).catch((err) => {
+        import_node_server_utils.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 import_mongodb.ObjectId(site);
+      cacheOptions.site = site.toString();
+    } catch {
+      throw new import_node_server_utils.BadRequestError("Invalid site ID format.");
+    }
+    const cacheKey = (0, import_node_server_utils.makeCacheKey)(
+      `${dashboard_namespace_collection}:weeklyActivity`,
+      cacheOptions
+    );
+    const cachedData = await getCache(cacheKey);
+    if (cachedData) {
+      import_node_server_utils.logger.info(`Cache hit for weeklyActivity: ${cacheKey}`);
+      return cachedData;
+    }
+    const workOrderService = workOrderServiceMap[serviceType] ?? serviceType;
+    const weekStart = import_moment_timezone.default.tz("Asia/Singapore").startOf("isoWeek").toDate();
+    const weekEnd = import_moment_timezone.default.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(() => {
+        import_node_server_utils.logger.info(`Cache set for weeklyActivity: ${cacheKey}`);
+      }).catch((err) => {
+        import_node_server_utils.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 import_mongodb.ObjectId(site);
+      cacheOptions.site = site.toString();
+    } catch {
+      throw new import_node_server_utils.BadRequestError("Invalid site ID format.");
+    }
+    const cacheKey = (0, import_node_server_utils.makeCacheKey)(
+      `${dashboard_namespace_collection}:todayTaskSchedule`,
+      cacheOptions
+    );
+    const cachedData = await getCache(cacheKey);
+    if (cachedData) {
+      import_node_server_utils.logger.info(`Cache hit for todayTaskSchedule: ${cacheKey}`);
+      return cachedData;
+    }
+    const todayStart = import_moment_timezone.default.tz("Asia/Singapore").startOf("day").toDate();
+    const todayEnd = import_moment_timezone.default.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" }
-        ]).toArray(),
-        scheduleTaskCollection.aggregate([
-          { $match: yesterDayQueries.scheduleTask },
-          { $count: "count" }
+          { $skip: page * limit },
+          { $limit: limit }
         ]).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 = (0, import_node_server_utils.paginate)(items, page, limit, length);
+      setCache(cacheKey, data, 15 * 60).then(() => {
+        import_node_server_utils.logger.info(`Cache set for todayTaskSchedule: ${cacheKey}`);
+      }).catch((err) => {
+        import_node_server_utils.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 import_mongodb.ObjectId(site);
+      cacheOptions.site = site.toString();
+    } catch {
+      throw new import_node_server_utils.BadRequestError("Invalid site ID format.");
+    }
+    const cacheKey = (0, import_node_server_utils.makeCacheKey)(
+      `${dashboard_namespace_collection}:staffAttendance`,
+      cacheOptions
+    );
+    const cachedData = await getCache(cacheKey);
+    if (cachedData) {
+      import_node_server_utils.logger.info(`Cache hit for staffAttendance: ${cacheKey}`);
+      return cachedData;
+    }
+    const todayStart = import_moment_timezone.default.tz("Asia/Singapore").startOf("day").toDate();
+    const todayEnd = import_moment_timezone.default.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 = (0, import_node_server_utils.paginate)(items, page, limit, length);
+      setCache(cacheKey, data, 15 * 60).then(() => {
+        import_node_server_utils.logger.info(`Cache set for staffAttendance: ${cacheKey}`);
+      }).catch((err) => {
+        import_node_server_utils.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 import_mongodb.ObjectId(site);
+      cacheOptions.site = site.toString();
+    } catch {
+      throw new import_node_server_utils.BadRequestError("Invalid site ID format.");
+    }
+    const cacheKey = (0, import_node_server_utils.makeCacheKey)(
+      `${dashboard_namespace_collection}:recentFeedbacks`,
+      cacheOptions
+    );
+    const cachedData = await getCache(cacheKey);
+    if (cachedData) {
+      import_node_server_utils.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(() => {
-        import_node_server_utils.logger.info(`Cache set for dashboard: ${dashboardCacheKey}`);
+      const data = (0, import_node_server_utils.paginate)(items, page, limit, length);
+      setCache(cacheKey, data, 15 * 60).then(() => {
+        import_node_server_utils.logger.info(`Cache set for recentFeedbacks: ${cacheKey}`);
       }).catch((err) => {
         import_node_server_utils.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
 var import_joi = __toESM(require("joi"));
 var import_node_server_utils2 = require("@7365admin1/node-server-utils");
+var import_core = require("@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 = import_joi.default.object({
       site: import_joi.default.string().hex().required(),
-      feedbackPeriod: import_joi.default.string().valid(...allowedPeriods).optional(),
-      commonAreaPeriod: import_joi.default.string().valid(...allowedPeriods).optional(),
-      toiletAreaPeriod: import_joi.default.string().valid(...allowedPeriods).optional(),
-      scheduleTaskPeriod: import_joi.default.string().valid(...allowedPeriods).optional(),
-      supplyPeriod: import_joi.default.string().valid(...allowedPeriods).optional(),
-      requestItemPeriod: import_joi.default.string().valid(...allowedPeriods).optional()
+      serviceType: import_joi.default.string().valid(...Object.values(import_core.AppServiceType)).required(),
+      period: import_joi.default.string().valid(...allowedPeriods).optional()
     });
     const { error } = validation.validate(query);
     if (error) {
@@ -589,21 +777,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) {
+      import_node_server_utils2.logger.log({ level: "error", message: error2.message });
+      next(error2);
+      return;
+    }
+  }
+  async function getWeeklyActivity(req, res, next) {
+    const query = { ...req.params };
+    const validation = import_joi.default.object({
+      site: import_joi.default.string().hex().required(),
+      serviceType: import_joi.default.string().valid(...Object.values(import_core.AppServiceType)).required()
+    });
+    const { error } = validation.validate(query);
+    if (error) {
+      import_node_server_utils2.logger.log({ level: "error", message: error.message });
+      next(new import_node_server_utils2.BadRequestError(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) {
+      import_node_server_utils2.logger.log({ level: "error", message: error2.message });
+      next(error2);
+      return;
+    }
+  }
+  async function getTodayTaskSchedule(req, res, next) {
+    const query = { ...req.query, ...req.params };
+    const validation = import_joi.default.object({
+      site: import_joi.default.string().hex().required(),
+      serviceType: import_joi.default.string().valid(...Object.values(import_core.AppServiceType)).required(),
+      page: import_joi.default.number().min(1).optional().allow("", null),
+      limit: import_joi.default.number().min(1).optional().allow("", null)
+    });
+    const { error } = validation.validate(query);
+    if (error) {
+      import_node_server_utils2.logger.log({ level: "error", message: error.message });
+      next(new import_node_server_utils2.BadRequestError(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) {
+      import_node_server_utils2.logger.log({ level: "error", message: error2.message });
+      next(error2);
+      return;
+    }
+  }
+  async function getStaffAttendance(req, res, next) {
+    const query = { ...req.query, ...req.params };
+    const validation = import_joi.default.object({
+      site: import_joi.default.string().hex().required(),
+      serviceType: import_joi.default.string().valid(...Object.values(import_core.AppServiceType)).required(),
+      page: import_joi.default.number().min(1).optional().allow("", null),
+      limit: import_joi.default.number().min(1).optional().allow("", null)
+    });
+    const { error } = validation.validate(query);
+    if (error) {
+      import_node_server_utils2.logger.log({ level: "error", message: error.message });
+      next(new import_node_server_utils2.BadRequestError(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) {
+      import_node_server_utils2.logger.log({ level: "error", message: error2.message });
+      next(error2);
+      return;
+    }
+  }
+  async function getRecentFeedbacks(req, res, next) {
+    const query = { ...req.query, ...req.params };
+    const validation = import_joi.default.object({
+      site: import_joi.default.string().hex().required(),
+      serviceType: import_joi.default.string().valid(...Object.values(import_core.AppServiceType)).required(),
+      page: import_joi.default.number().min(1).optional().allow("", null),
+      limit: import_joi.default.number().min(1).optional().allow("", null)
+    });
+    const { error } = validation.validate(query);
+    if (error) {
+      import_node_server_utils2.logger.log({ level: "error", message: error.message });
+      next(new import_node_server_utils2.BadRequestError(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;
@@ -614,7 +917,11 @@ function useHygieneDashboardController() {
     }
   }
   return {
-    getHygieneDashboard
+    getHygieneDashboard,
+    getWeeklyActivity,
+    getTodayTaskSchedule,
+    getStaffAttendance,
+    getRecentFeedbacks
   };
 }
 
@@ -622,10 +929,10 @@ function useHygieneDashboardController() {
 var import_joi2 = __toESM(require("joi"));
 var import_mongodb2 = require("mongodb");
 var import_node_server_utils3 = require("@7365admin1/node-server-utils");
-var import_core = require("@7365admin1/core");
+var import_core2 = require("@7365admin1/core");
 var areaSchema = import_joi2.default.object({
   site: import_joi2.default.string().hex().required(),
-  serviceType: import_joi2.default.string().valid(...Object.values(import_core.AppServiceType)).required(),
+  serviceType: import_joi2.default.string().valid(...Object.values(import_core2.AppServiceType)).required(),
   name: import_joi2.default.string().required(),
   type: import_joi2.default.string().valid(...allowedTypes).required(),
   set: import_joi2.default.number().min(0).optional(),
@@ -1129,10 +1436,10 @@ var import_node_server_utils7 = require("@7365admin1/node-server-utils");
 var import_joi3 = __toESM(require("joi"));
 var import_mongodb4 = require("mongodb");
 var import_node_server_utils6 = require("@7365admin1/node-server-utils");
-var import_core2 = require("@7365admin1/core");
+var import_core3 = require("@7365admin1/core");
 var unitSchema = import_joi3.default.object({
   site: import_joi3.default.string().hex().required(),
-  serviceType: import_joi3.default.string().valid(...Object.values(import_core2.AppServiceType)).required(),
+  serviceType: import_joi3.default.string().valid(...Object.values(import_core3.AppServiceType)).required(),
   name: import_joi3.default.string().required()
 });
 function MUnit(value) {
@@ -1553,7 +1860,7 @@ function useAreaService() {
 // src/controllers/hygiene-area.controller.ts
 var import_joi4 = __toESM(require("joi"));
 var import_node_server_utils9 = require("@7365admin1/node-server-utils");
-var import_core3 = require("@7365admin1/core");
+var import_core4 = require("@7365admin1/core");
 
 // src/utils/convert-excel.util.ts
 var import_stream = require("stream");
@@ -1618,7 +1925,7 @@ function useAreaController() {
       search: import_joi4.default.string().optional().allow("", null),
       type: import_joi4.default.string().valid("all", ...allowedTypes).optional().allow("", null),
       site: import_joi4.default.string().hex().required(),
-      serviceType: import_joi4.default.string().valid(...Object.values(import_core3.AppServiceType)).required()
+      serviceType: import_joi4.default.string().valid(...Object.values(import_core4.AppServiceType)).required()
     });
     const { error } = validation.validate(query);
     if (error) {
@@ -1727,7 +2034,7 @@ function useAreaController() {
     const query = { ...req.query, ...req.params };
     const validation = import_joi4.default.object({
       site: import_joi4.default.string().hex().required(),
-      serviceType: import_joi4.default.string().valid(...Object.values(import_core3.AppServiceType)).required()
+      serviceType: import_joi4.default.string().valid(...Object.values(import_core4.AppServiceType)).required()
     });
     const { error, value } = validation.validate(query);
     if (error) {
@@ -1750,7 +2057,7 @@ function useAreaController() {
     const query = { ...req.query, ...req.params };
     const validation = import_joi4.default.object({
       site: import_joi4.default.string().hex().required(),
-      serviceType: import_joi4.default.string().valid(...Object.values(import_core3.AppServiceType)).required()
+      serviceType: import_joi4.default.string().valid(...Object.values(import_core4.AppServiceType)).required()
     });
     const { error, value } = validation.validate(query);
     if (error) {
@@ -2028,7 +2335,7 @@ function useUnitService() {
 // src/controllers/hygiene-unit.controller.ts
 var import_joi5 = __toESM(require("joi"));
 var import_node_server_utils12 = require("@7365admin1/node-server-utils");
-var import_core4 = require("@7365admin1/core");
+var import_core5 = require("@7365admin1/core");
 function useUnitController() {
   const { createUnit: _createUnit, getUnits: _getUnits } = useUnitRepository();
   const {
@@ -2062,7 +2369,7 @@ function useUnitController() {
       limit: import_joi5.default.number().min(1).optional().allow("", null),
       search: import_joi5.default.string().optional().allow("", null),
       site: import_joi5.default.string().hex().required(),
-      serviceType: import_joi5.default.string().valid(...Object.values(import_core4.AppServiceType)).required()
+      serviceType: import_joi5.default.string().valid(...Object.values(import_core5.AppServiceType)).required()
     });
     const { error } = validation.validate(query);
     if (error) {
@@ -2143,7 +2450,7 @@ function useUnitController() {
     const query = { ...req.query, ...req.params };
     const validation = import_joi5.default.object({
       site: import_joi5.default.string().hex().required(),
-      serviceType: import_joi5.default.string().valid(...Object.values(import_core4.AppServiceType)).required()
+      serviceType: import_joi5.default.string().valid(...Object.values(import_core5.AppServiceType)).required()
     });
     const { error, value } = validation.validate(query);
     if (error) {
@@ -2166,7 +2473,7 @@ function useUnitController() {
     const query = { ...req.query, ...req.params };
     const validation = import_joi5.default.object({
       site: import_joi5.default.string().hex().required(),
-      serviceType: import_joi5.default.string().valid(...Object.values(import_core4.AppServiceType)).required()
+      serviceType: import_joi5.default.string().valid(...Object.values(import_core5.AppServiceType)).required()
     });
     const { error, value } = validation.validate(query);
     if (error) {
@@ -2212,11 +2519,11 @@ function useUnitController() {
 var import_joi6 = __toESM(require("joi"));
 var import_mongodb6 = require("mongodb");
 var import_node_server_utils13 = require("@7365admin1/node-server-utils");
-var import_core5 = require("@7365admin1/core");
+var import_core6 = require("@7365admin1/core");
 var parentChecklistSchema = import_joi6.default.object({
   createdAt: import_joi6.default.alternatives().try(import_joi6.default.date(), import_joi6.default.string()).optional().allow("", null),
   site: import_joi6.default.string().hex().required(),
-  serviceType: import_joi6.default.string().valid(...Object.values(import_core5.AppServiceType)).required()
+  serviceType: import_joi6.default.string().valid(...Object.values(import_core6.AppServiceType)).required()
 });
 function MParentChecklist(value) {
   const { error } = parentChecklistSchema.validate(value);
@@ -2243,7 +2550,7 @@ function MParentChecklist(value) {
 // src/repositories/hygiene-parent-checklist.repository.ts
 var import_mongodb7 = require("mongodb");
 var import_node_server_utils14 = require("@7365admin1/node-server-utils");
-var import_core6 = require("@7365admin1/core");
+var import_core7 = require("@7365admin1/core");
 function useParentChecklistRepo() {
   const db = import_node_server_utils14.useAtlas.getDb();
   if (!db) {
@@ -2275,7 +2582,7 @@ function useParentChecklistRepo() {
       startOfDay.setUTCHours(0, 0, 0, 0);
       const endOfDay = new Date(currentDate);
       endOfDay.setUTCHours(23, 59, 59, 999);
-      const allServiceTypes = Object.values(import_core6.AppServiceType);
+      const allServiceTypes = Object.values(import_core7.AppServiceType);
       const dateStr = currentDate.toISOString().split("T")[0];
       if (value.site) {
         let siteObjectId;
@@ -2680,7 +2987,7 @@ function useParentChecklistRepo() {
 // src/controllers/hygiene-parent-checklist.controller.ts
 var import_joi7 = __toESM(require("joi"));
 var import_node_server_utils15 = require("@7365admin1/node-server-utils");
-var import_core7 = require("@7365admin1/core");
+var import_core8 = require("@7365admin1/core");
 function useParentChecklistController() {
   const {
     createParentChecklist: _createParentChecklist,
@@ -2691,7 +2998,7 @@ function useParentChecklistController() {
     const validation = import_joi7.default.object({
       createdAt: import_joi7.default.alternatives().try(import_joi7.default.date(), import_joi7.default.string()).optional().allow("", null),
       site: import_joi7.default.string().hex().required(),
-      serviceType: import_joi7.default.string().valid(...Object.values(import_core7.AppServiceType)).optional().allow("", null)
+      serviceType: import_joi7.default.string().valid(...Object.values(import_core8.AppServiceType)).optional().allow("", null)
     });
     const { error } = validation.validate(payload);
     if (error) {
@@ -2716,7 +3023,7 @@ function useParentChecklistController() {
       limit: import_joi7.default.number().min(1).optional().allow("", null),
       search: import_joi7.default.string().optional().allow("", null),
       site: import_joi7.default.string().hex().required(),
-      serviceType: import_joi7.default.string().valid(...Object.values(import_core7.AppServiceType)).required(),
+      serviceType: import_joi7.default.string().valid(...Object.values(import_core8.AppServiceType)).required(),
       startDate: import_joi7.default.alternatives().try(import_joi7.default.date(), import_joi7.default.string()).optional().allow("", null),
       endDate: import_joi7.default.alternatives().try(import_joi7.default.date(), import_joi7.default.string()).optional().allow("", null),
       status: import_joi7.default.string().valid(...allowedStatus, "all").optional().allow("", null)
@@ -2764,11 +3071,11 @@ function useParentChecklistController() {
 var import_joi8 = __toESM(require("joi"));
 var import_mongodb8 = require("mongodb");
 var import_node_server_utils16 = require("@7365admin1/node-server-utils");
-var import_core8 = require("@7365admin1/core");
+var import_core9 = require("@7365admin1/core");
 var allowedChecklistStatus = ["open", "completed", "closed"];
 var areaChecklistSchema = import_joi8.default.object({
   schedule: import_joi8.default.string().hex().required(),
-  serviceType: import_joi8.default.string().valid(...Object.values(import_core8.AppServiceType)).required(),
+  serviceType: import_joi8.default.string().valid(...Object.values(import_core9.AppServiceType)).required(),
   area: import_joi8.default.string().hex().required(),
   name: import_joi8.default.string().required(),
   type: import_joi8.default.string().valid(...allowedTypes).required(),
@@ -2842,7 +3149,7 @@ function MAreaChecklist(value) {
 // src/services/hygiene-area-checklist.service.ts
 var import_mongodb10 = require("mongodb");
 var import_node_server_utils18 = require("@7365admin1/node-server-utils");
-var import_core9 = require("@7365admin1/core");
+var import_core10 = require("@7365admin1/core");
 
 // src/repositories/hygiene-area-checklist.repository.ts
 var import_mongodb9 = require("mongodb");
@@ -3978,7 +4285,7 @@ function useAreaChecklistService() {
     insertAutoGenSets
   } = useAreaChecklistRepo();
   const { updateParentChecklistStatuses, getParentChecklistById } = useParentChecklistRepo();
-  const { getUserById } = (0, import_core9.useUserRepo)();
+  const { getUserById } = (0, import_core10.useUserRepo)();
   async function createAreaChecklist(value) {
     const results = [];
     let totalChecklistsCreated = 0;
@@ -4204,7 +4511,7 @@ function useAreaChecklistService() {
 // src/controllers/hygiene-area-checklist.controller.ts
 var import_joi9 = __toESM(require("joi"));
 var import_node_server_utils20 = require("@7365admin1/node-server-utils");
-var import_core10 = require("@7365admin1/core");
+var import_core11 = require("@7365admin1/core");
 
 // src/services/hygiene-checklist-pdf.service.ts
 var import_puppeteer = require("puppeteer");
@@ -4471,7 +4778,7 @@ function useAreaChecklistController() {
       type: import_joi9.default.string().valid(...allowedTypes, "all").optional().allow("", null),
       status: import_joi9.default.string().valid(...allowedStatus, "all").optional().allow("", null),
       schedule: import_joi9.default.string().hex().required(),
-      serviceType: import_joi9.default.string().valid(...Object.values(import_core10.AppServiceType)).required()
+      serviceType: import_joi9.default.string().valid(...Object.values(import_core11.AppServiceType)).required()
     });
     const { error } = validation.validate(query);
     if (error) {
@@ -4571,7 +4878,7 @@ function useAreaChecklistController() {
       page: import_joi9.default.number().min(1).optional().allow("", null),
       limit: import_joi9.default.number().min(1).optional().allow("", null),
       search: import_joi9.default.string().optional().allow("", null),
-      serviceType: import_joi9.default.string().valid(...Object.values(import_core10.AppServiceType)).required(),
+      serviceType: import_joi9.default.string().valid(...Object.values(import_core11.AppServiceType)).required(),
       id: import_joi9.default.string().hex().required()
     });
     const { error } = validation.validate(query);
@@ -4700,10 +5007,10 @@ function useAreaChecklistController() {
 var import_joi10 = __toESM(require("joi"));
 var import_mongodb12 = require("mongodb");
 var import_node_server_utils21 = require("@7365admin1/node-server-utils");
-var import_core11 = require("@7365admin1/core");
+var import_core12 = require("@7365admin1/core");
 var supplySchema = import_joi10.default.object({
   site: import_joi10.default.string().hex().required(),
-  serviceType: import_joi10.default.string().valid(...Object.values(import_core11.AppServiceType)).required(),
+  serviceType: import_joi10.default.string().valid(...Object.values(import_core12.AppServiceType)).required(),
   name: import_joi10.default.string().required(),
   unitOfMeasurement: import_joi10.default.string().required()
 });
@@ -4985,7 +5292,7 @@ function useSupplyRepository() {
 // src/controllers/hygiene-supply.controller.ts
 var import_joi11 = __toESM(require("joi"));
 var import_node_server_utils23 = require("@7365admin1/node-server-utils");
-var import_core12 = require("@7365admin1/core");
+var import_core13 = require("@7365admin1/core");
 function useSupplyController() {
   const {
     createSupply: _createSupply,
@@ -5019,7 +5326,7 @@ function useSupplyController() {
       limit: import_joi11.default.number().min(1).optional().allow("", null),
       search: import_joi11.default.string().optional().allow("", null),
       site: import_joi11.default.string().hex().required(),
-      serviceType: import_joi11.default.string().valid(...Object.values(import_core12.AppServiceType)).required()
+      serviceType: import_joi11.default.string().valid(...Object.values(import_core13.AppServiceType)).required()
     });
     const { error } = validation.validate(query);
     if (error) {
@@ -5124,10 +5431,10 @@ function useSupplyController() {
 var import_joi12 = __toESM(require("joi"));
 var import_mongodb14 = require("mongodb");
 var import_node_server_utils24 = require("@7365admin1/node-server-utils");
-var import_core13 = require("@7365admin1/core");
+var import_core14 = require("@7365admin1/core");
 var stockSchema = import_joi12.default.object({
   site: import_joi12.default.string().hex().required(),
-  serviceType: import_joi12.default.string().valid(...Object.values(import_core13.AppServiceType)).required(),
+  serviceType: import_joi12.default.string().valid(...Object.values(import_core14.AppServiceType)).required(),
   supply: import_joi12.default.string().hex().required(),
   in: import_joi12.default.number().min(0).optional(),
   out: import_joi12.default.number().min(0).optional(),
@@ -5349,7 +5656,7 @@ function useStockService() {
 // src/controllers/hygiene-stock.controller.ts
 var import_joi13 = __toESM(require("joi"));
 var import_node_server_utils27 = require("@7365admin1/node-server-utils");
-var import_core14 = require("@7365admin1/core");
+var import_core15 = require("@7365admin1/core");
 function useStockController() {
   const { getStocksBySupplyId: _getStocksBySupplyId } = useStockRepository();
   const { createStock: _createStock } = useStockService();
@@ -5357,7 +5664,7 @@ function useStockController() {
     const payload = { ...req.body, ...req.params };
     const validation = import_joi13.default.object({
       site: import_joi13.default.string().hex().required(),
-      serviceType: import_joi13.default.string().valid(...Object.values(import_core14.AppServiceType)).required(),
+      serviceType: import_joi13.default.string().valid(...Object.values(import_core15.AppServiceType)).required(),
       supply: import_joi13.default.string().hex().required(),
       qty: import_joi13.default.number().min(0).required(),
       remarks: import_joi13.default.string().optional().allow("", null)
@@ -5385,7 +5692,7 @@ function useStockController() {
       limit: import_joi13.default.number().min(1).optional().allow("", null),
       search: import_joi13.default.string().optional().allow("", null),
       site: import_joi13.default.string().hex().required(),
-      serviceType: import_joi13.default.string().valid(...Object.values(import_core14.AppServiceType)).required(),
+      serviceType: import_joi13.default.string().valid(...Object.values(import_core15.AppServiceType)).required(),
       supply: import_joi13.default.string().hex().required()
     });
     const { error } = validation.validate(query);
@@ -5427,11 +5734,11 @@ function useStockController() {
 var import_joi14 = __toESM(require("joi"));
 var import_mongodb16 = require("mongodb");
 var import_node_server_utils28 = require("@7365admin1/node-server-utils");
-var import_core15 = require("@7365admin1/core");
+var import_core16 = require("@7365admin1/core");
 var allowedCheckOutItemStatus = ["pending", "completed"];
 var checkOutItemSchema = import_joi14.default.object({
   site: import_joi14.default.string().hex().required(),
-  serviceType: import_joi14.default.string().valid(...Object.values(import_core15.AppServiceType)).required(),
+  serviceType: import_joi14.default.string().valid(...Object.values(import_core16.AppServiceType)).required(),
   supply: import_joi14.default.string().hex().required(),
   supplyName: import_joi14.default.string().required(),
   qty: import_joi14.default.number().min(0).required(),
@@ -5492,6 +5799,7 @@ function useCheckOutItemRepository() {
         { key: { site: 1 } },
         { key: { serviceType: 1 } },
         { key: { supply: 1 } },
+        { key: { createdBy: 1 } },
         { key: { status: 1 } }
       ]);
     } catch (error) {
@@ -5523,7 +5831,11 @@ function useCheckOutItemRepository() {
       });
       return res.insertedId;
     } catch (error) {
-      throw error;
+      if (error.code === 11e3) {
+        throw "The Item is already exisits";
+      } else {
+        throw error;
+      }
     }
   }
   async function getCheckOutItems({
@@ -5589,11 +5901,35 @@ function useCheckOutItemRepository() {
             preserveNullAndEmptyArrays: true
           }
         },
+        {
+          $lookup: {
+            from: "users",
+            let: { createdByStr: "$createdBy" },
+            pipeline: [
+              {
+                $match: {
+                  $expr: {
+                    $eq: [{ $toString: "$_id" }, "$$createdByStr"]
+                  }
+                }
+              },
+              { $project: { profile: 1 } }
+            ],
+            as: "createdByDoc"
+          }
+        },
+        {
+          $unwind: {
+            path: "$createdByDoc",
+            preserveNullAndEmptyArrays: true
+          }
+        },
         {
           $project: {
             supplyName: 1,
             supplyQty: "$supplyDoc.qty",
             checkOutByName: "$createdByName",
+            profile: "$createdByDoc.profile",
             checkOutQty: "$qty",
             createdAt: 1,
             status: 1
@@ -5723,7 +6059,7 @@ function useCheckOutItemRepository() {
 }
 
 // src/services/hygiene-checkout-item.service.ts
-var import_core16 = require("@7365admin1/core");
+var import_core17 = require("@7365admin1/core");
 var import_node_server_utils30 = require("@7365admin1/node-server-utils");
 function useCheckOutItemService() {
   const {
@@ -5732,7 +6068,7 @@ function useCheckOutItemService() {
     completeCheckOutItem
   } = useCheckOutItemRepository();
   const { getSupplyById } = useSupplyRepository();
-  const { getUserById } = (0, import_core16.useUserRepo)();
+  const { getUserById } = (0, import_core17.useUserRepo)();
   const { createStock } = useStockService();
   async function createCheckOutItem(value) {
     const session = import_node_server_utils30.useAtlas.getClient()?.startSession();
@@ -5827,7 +6163,7 @@ function useCheckOutItemService() {
 // src/controllers/hygiene-checkout-item.controller.ts
 var import_joi15 = __toESM(require("joi"));
 var import_node_server_utils31 = require("@7365admin1/node-server-utils");
-var import_core17 = require("@7365admin1/core");
+var import_core18 = require("@7365admin1/core");
 function useCheckOutItemController() {
   const {
     getCheckOutItems: _getCheckOutItems,
@@ -5850,7 +6186,7 @@ function useCheckOutItemController() {
     };
     const validation = import_joi15.default.object({
       site: import_joi15.default.string().hex().required(),
-      serviceType: import_joi15.default.string().valid(...Object.values(import_core17.AppServiceType)).required(),
+      serviceType: import_joi15.default.string().valid(...Object.values(import_core18.AppServiceType)).required(),
       supply: import_joi15.default.string().hex().required(),
       qty: import_joi15.default.number().min(0).required(),
       attachment: import_joi15.default.array().items(import_joi15.default.string()).optional().allow(null),
@@ -5885,7 +6221,7 @@ function useCheckOutItemController() {
     };
     const validation = import_joi15.default.object({
       site: import_joi15.default.string().hex().required(),
-      serviceType: import_joi15.default.string().valid(...Object.values(import_core17.AppServiceType)).required(),
+      serviceType: import_joi15.default.string().valid(...Object.values(import_core18.AppServiceType)).required(),
       createdBy: import_joi15.default.string().hex().required(),
       items: import_joi15.default.array().items(
         import_joi15.default.object({
@@ -5918,7 +6254,7 @@ function useCheckOutItemController() {
       limit: import_joi15.default.number().min(1).optional().allow("", null),
       search: import_joi15.default.string().optional().allow("", null),
       site: import_joi15.default.string().hex().required(),
-      serviceType: import_joi15.default.string().valid(...Object.values(import_core17.AppServiceType)).required()
+      serviceType: import_joi15.default.string().valid(...Object.values(import_core18.AppServiceType)).required()
     });
     const { error } = validation.validate(query);
     if (error) {
@@ -5976,12 +6312,12 @@ function useCheckOutItemController() {
 
 // src/models/hygiene-schedule-task.model.ts
 var import_node_server_utils32 = require("@7365admin1/node-server-utils");
-var import_core18 = require("@7365admin1/core");
+var import_core19 = require("@7365admin1/core");
 var import_joi16 = __toESM(require("joi"));
 var import_mongodb18 = require("mongodb");
 var scheduleTaskSchema = import_joi16.default.object({
   site: import_joi16.default.string().hex().required(),
-  serviceType: import_joi16.default.string().valid(...Object.values(import_core18.AppServiceType)).required(),
+  serviceType: import_joi16.default.string().valid(...Object.values(import_core19.AppServiceType)).required(),
   title: import_joi16.default.string().required(),
   time: import_joi16.default.string().pattern(/^([0-1]\d|2[0-3]):([0-5]\d)$/).required(),
   dates: import_joi16.default.array().min(1).items(
@@ -6587,7 +6923,7 @@ function useScheduleTaskService() {
 // src/controllers/hygiene-schedule-task.controller.ts
 var import_joi17 = __toESM(require("joi"));
 var import_node_server_utils35 = require("@7365admin1/node-server-utils");
-var import_core19 = require("@7365admin1/core");
+var import_core20 = require("@7365admin1/core");
 function useScheduleTaskController() {
   const {
     createScheduleTask: _createScheduleTask,
@@ -6621,7 +6957,7 @@ function useScheduleTaskController() {
       limit: import_joi17.default.number().min(1).optional().allow("", null),
       search: import_joi17.default.string().optional().allow("", null),
       site: import_joi17.default.string().hex().required(),
-      serviceType: import_joi17.default.string().valid(...Object.values(import_core19.AppServiceType)).required()
+      serviceType: import_joi17.default.string().valid(...Object.values(import_core20.AppServiceType)).required()
     });
     const { error } = validation.validate(query);
     if (error) {