@7365admin1/core 2.20.0 → 2.21.0

package/dist/index.js

@@ -65,6 +65,8 @@ __export(src_exports, {
   MFile: () => MFile,
   MGuestManagement: () => MGuestManagement,
   MIncidentReport: () => MIncidentReport,
+  MManpowerDesignations: () => MManpowerDesignations,
+  MManpowerMonitoring: () => MManpowerMonitoring,
   MMember: () => MMember,
   MNfcPatrolLog: () => MNfcPatrolLog,
   MNfcPatrolRoute: () => MNfcPatrolRoute,
@@ -76,6 +78,7 @@ __export(src_exports, {
   MOccurrenceSubject: () => MOccurrenceSubject,
   MOnlineForm: () => MOnlineForm,
   MOrg: () => MOrg,
+  MOvernightParkingApprovalHours: () => MOvernightParkingApprovalHours,
   MPatrolLog: () => MPatrolLog,
   MPatrolQuestion: () => MPatrolQuestion,
   MPatrolRoute: () => MPatrolRoute,
@@ -101,6 +104,8 @@ __export(src_exports, {
   MWorkOrder: () => MWorkOrder,
   OrgNature: () => OrgNature,
   PERSON_TYPES: () => PERSON_TYPES,
+  PMDashboardCollection: () => PMDashboardCollection,
+  Period: () => Period,
   PersonTypes: () => PersonTypes,
   SiteCategories: () => SiteCategories,
   SiteStatus: () => SiteStatus,
@@ -118,14 +123,30 @@ __export(src_exports, {
   allowedNatures: () => allowedNatures,
   attendanceSchema: () => attendanceSchema,
   attendanceSettingsSchema: () => attendanceSettingsSchema,
+  buildings_namespace_collection: () => buildings_namespace_collection,
+  bulletin_boards_namespace_collection: () => bulletin_boards_namespace_collection,
+  calculatePercentage: () => calculatePercentage,
   chatSchema: () => chatSchema,
   customerSchema: () => customerSchema,
+  designationsSchema: () => designationsSchema,
+  events_namespace_collection: () => events_namespace_collection,
+  facility_bookings_namespace_collection: () => facility_bookings_namespace_collection,
   feedbackSchema: () => feedbackSchema,
+  feedbacks_namespace_collection: () => feedbacks_namespace_collection,
   formatDahuaDate: () => formatDahuaDate,
+  getPeriodRangeWithPrevious: () => getPeriodRangeWithPrevious,
+  guests_namespace_collection: () => guests_namespace_collection,
   incidentReportLog: () => incidentReportLog,
+  incidents_namespace_collection: () => incidents_namespace_collection,
+  landscapeDashboardCollection: () => landscapeDashboardCollection,
+  mAndEDashboardCollection: () => mAndEDashboardCollection,
+  manpowerDesignationsSchema: () => manpowerDesignationsSchema,
+  manpowerMonitoringSchema: () => manpowerMonitoringSchema,
   nfcPatrolSettingsSchema: () => nfcPatrolSettingsSchema,
   nfcPatrolSettingsSchemaUpdate: () => nfcPatrolSettingsSchemaUpdate,
   orgSchema: () => orgSchema,
+  pestDashboardCollection: () => pestDashboardCollection,
+  poolDashboardCollection: () => poolDashboardCollection,
   promoCodeSchema: () => promoCodeSchema,
   robotSchema: () => robotSchema,
   schema: () => schema,
@@ -152,6 +173,7 @@ __export(src_exports, {
   schemaOccurrenceEntry: () => schemaOccurrenceEntry,
   schemaOccurrenceSubject: () => schemaOccurrenceSubject,
   schemaOnlineForm: () => schemaOnlineForm,
+  schemaOvernightParkingApprovalHours: () => schemaOvernightParkingApprovalHours,
   schemaPatrolLog: () => schemaPatrolLog,
   schemaPatrolQuestion: () => schemaPatrolQuestion,
   schemaPatrolRoute: () => schemaPatrolRoute,
@@ -193,7 +215,10 @@ __export(src_exports, {
   schemaVisitorTransaction: () => schemaVisitorTransaction,
   schemeCamera: () => schemeCamera,
   schemeLogCamera: () => schemeLogCamera,
+  securityDashboardCollection: () => securityDashboardCollection,
+  shiftSchema: () => shiftSchema,
   siteSchema: () => siteSchema,
+  site_people_namespace_collection: () => site_people_namespace_collection,
   tokenSchema: () => tokenSchema,
   updateSiteSchema: () => updateSiteSchema,
   useAccessManagementController: () => useAccessManagementController,
@@ -252,8 +277,15 @@ __export(src_exports, {
   useInvoiceController: () => useInvoiceController,
   useInvoiceModel: () => useInvoiceModel,
   useInvoiceRepo: () => useInvoiceRepo,
+  useManpowerDesignationCtrl: () => useManpowerDesignationCtrl,
+  useManpowerDesignationRepo: () => useManpowerDesignationRepo,
+  useManpowerMonitoringCtrl: () => useManpowerMonitoringCtrl,
+  useManpowerMonitoringRepo: () => useManpowerMonitoringRepo,
+  useManpowerMonitoringSrvc: () => useManpowerMonitoringSrvc,
   useMemberController: () => useMemberController,
   useMemberRepo: () => useMemberRepo,
+  useNewDashboardController: () => useNewDashboardController,
+  useNewDashboardRepo: () => useNewDashboardRepo,
   useNfcPatrolLogController: () => useNfcPatrolLogController,
   useNfcPatrolLogRepo: () => useNfcPatrolLogRepo,
   useNfcPatrolLogService: () => useNfcPatrolLogService,
@@ -279,6 +311,8 @@ __export(src_exports, {
   useOnlineFormRepo: () => useOnlineFormRepo,
   useOrgController: () => useOrgController,
   useOrgRepo: () => useOrgRepo,
+  useOvernightParkingController: () => useOvernightParkingController,
+  useOvernightParkingRepo: () => useOvernightParkingRepo,
   usePatrolLogController: () => usePatrolLogController,
   usePatrolLogRepo: () => usePatrolLogRepo,
   usePatrolQuestionController: () => usePatrolQuestionController,
@@ -344,7 +378,10 @@ __export(src_exports, {
   useWorkOrderService: () => useWorkOrderService,
   userSchema: () => userSchema,
   vehicleSchema: () => vehicleSchema,
-  workOrderSchema: () => workOrderSchema
+  vehicles_namespace_collection: () => vehicles_namespace_collection,
+  visitors_namespace_collection: () => visitors_namespace_collection,
+  workOrderSchema: () => workOrderSchema,
+  work_orders_namespace_collection: () => work_orders_namespace_collection
 });
 module.exports = __toCommonJS(src_exports);
 
@@ -594,14 +631,16 @@ function MFeedback(value) {
 
 // src/repositories/feedback.repo.ts
 var import_node_server_utils5 = require("@7365admin1/node-server-utils");
+var feedbacks_namespace_collection = "feedbacks";
 function useFeedbackRepo() {
   const db = import_node_server_utils5.useAtlas.getDb();
   if (!db) {
     throw new import_node_server_utils5.InternalServerError("Unable to connect to server.");
   }
-  const namespace_collection = "feedbacks";
-  const collection = db.collection(namespace_collection);
-  const { delNamespace, getCache, setCache } = (0, import_node_server_utils5.useCache)(namespace_collection);
+  const collection = db.collection(feedbacks_namespace_collection);
+  const { delNamespace, getCache, setCache } = (0, import_node_server_utils5.useCache)(
+    feedbacks_namespace_collection
+  );
   const { delNamespace: _delDashboardNameSpace } = (0, import_node_server_utils5.useCache)("dashboard");
   async function createIndex() {
     try {
@@ -635,10 +674,12 @@ function useFeedbackRepo() {
       value = MFeedback(value);
       const res = await collection.insertOne(value, { session });
       delNamespace().then(() => {
-        import_node_server_utils5.logger.info(`Cache cleared for namespace: ${namespace_collection}`);
+        import_node_server_utils5.logger.info(
+          `Cache cleared for namespace: ${feedbacks_namespace_collection}`
+        );
       }).catch((err) => {
         import_node_server_utils5.logger.error(
-          `Failed to clear cache for namespace: ${namespace_collection}`,
+          `Failed to clear cache for namespace: ${feedbacks_namespace_collection}`,
           err
         );
       });
@@ -726,7 +767,7 @@ function useFeedbackRepo() {
       cacheOptions.to = to;
     }
     console.log("query", JSON.stringify(query));
-    const cacheKey = (0, import_node_server_utils5.makeCacheKey)(namespace_collection, cacheOptions);
+    const cacheKey = (0, import_node_server_utils5.makeCacheKey)(feedbacks_namespace_collection, cacheOptions);
     const cachedData = await getCache(cacheKey);
     if (cachedData) {
       import_node_server_utils5.logger.info(`Cache hit for key: ${cacheKey}`);
@@ -782,7 +823,7 @@ function useFeedbackRepo() {
     } catch (error) {
       throw new import_node_server_utils5.BadRequestError("Invalid feedback ID format.");
     }
-    const cacheKey = (0, import_node_server_utils5.makeCacheKey)(namespace_collection, { _id });
+    const cacheKey = (0, import_node_server_utils5.makeCacheKey)(feedbacks_namespace_collection, { _id });
     const cachedData = await getCache(cacheKey);
     if (cachedData) {
       import_node_server_utils5.logger.info(`Cache hit for key: ${cacheKey}`);
@@ -892,10 +933,12 @@ function useFeedbackRepo() {
         throw new import_node_server_utils5.InternalServerError("Unable to update feedback.");
       }
       delNamespace().then(() => {
-        import_node_server_utils5.logger.info(`Cache cleared for namespace: ${namespace_collection}`);
+        import_node_server_utils5.logger.info(
+          `Cache cleared for namespace: ${feedbacks_namespace_collection}`
+        );
       }).catch((err) => {
         import_node_server_utils5.logger.error(
-          `Failed to clear cache for namespace: ${namespace_collection}`,
+          `Failed to clear cache for namespace: ${feedbacks_namespace_collection}`,
           err
         );
       });
@@ -926,10 +969,12 @@ function useFeedbackRepo() {
         throw new import_node_server_utils5.InternalServerError("Unable to update feedback status.");
       }
       delNamespace().then(() => {
-        import_node_server_utils5.logger.info(`Cache cleared for namespace: ${namespace_collection}`);
+        import_node_server_utils5.logger.info(
+          `Cache cleared for namespace: ${feedbacks_namespace_collection}`
+        );
       }).catch((err) => {
         import_node_server_utils5.logger.error(
-          `Failed to clear cache for namespace: ${namespace_collection}`,
+          `Failed to clear cache for namespace: ${feedbacks_namespace_collection}`,
           err
         );
       });
@@ -950,10 +995,12 @@ function useFeedbackRepo() {
         session
       );
       delNamespace().then(() => {
-        import_node_server_utils5.logger.info(`Cache cleared for namespace: ${namespace_collection}`);
+        import_node_server_utils5.logger.info(
+          `Cache cleared for namespace: ${feedbacks_namespace_collection}`
+        );
       }).catch((err) => {
         import_node_server_utils5.logger.error(
-          `Failed to clear cache for namespace: ${namespace_collection}`,
+          `Failed to clear cache for namespace: ${feedbacks_namespace_collection}`,
           err
         );
       });
@@ -985,10 +1032,12 @@ function useFeedbackRepo() {
         throw new import_node_server_utils5.InternalServerError("Unable to update feedback category.");
       }
       delNamespace().then(() => {
-        import_node_server_utils5.logger.info(`Cache cleared for namespace: ${namespace_collection}`);
+        import_node_server_utils5.logger.info(
+          `Cache cleared for namespace: ${feedbacks_namespace_collection}`
+        );
       }).catch((err) => {
         import_node_server_utils5.logger.error(
-          `Failed to clear cache for namespace: ${namespace_collection}`,
+          `Failed to clear cache for namespace: ${feedbacks_namespace_collection}`,
           err
         );
       });
@@ -1022,10 +1071,12 @@ function useFeedbackRepo() {
         throw new import_node_server_utils5.InternalServerError("Unable to mark feedback as completed.");
       }
       delNamespace().then(() => {
-        import_node_server_utils5.logger.info(`Cache cleared for namespace: ${namespace_collection}`);
+        import_node_server_utils5.logger.info(
+          `Cache cleared for namespace: ${feedbacks_namespace_collection}`
+        );
       }).catch((err) => {
         import_node_server_utils5.logger.error(
-          `Failed to clear cache for namespace: ${namespace_collection}`,
+          `Failed to clear cache for namespace: ${feedbacks_namespace_collection}`,
           err
         );
       });
@@ -1060,10 +1111,12 @@ function useFeedbackRepo() {
         throw new import_node_server_utils5.InternalServerError("Unable to delete feedback.");
       }
       delNamespace().then(() => {
-        import_node_server_utils5.logger.info(`Cache cleared for namespace: ${namespace_collection}`);
+        import_node_server_utils5.logger.info(
+          `Cache cleared for namespace: ${feedbacks_namespace_collection}`
+        );
       }).catch((err) => {
         import_node_server_utils5.logger.error(
-          `Failed to clear cache for namespace: ${namespace_collection}`,
+          `Failed to clear cache for namespace: ${feedbacks_namespace_collection}`,
           err
         );
       });
@@ -1214,13 +1267,13 @@ function MWorkOrder(value) {
 
 // src/repositories/work-order.repo.ts
 var import_node_server_utils7 = require("@7365admin1/node-server-utils");
+var work_orders_namespace_collection = "work-orders";
 function useWorkOrderRepo() {
   const db = import_node_server_utils7.useAtlas.getDb();
   if (!db) {
     throw new import_node_server_utils7.InternalServerError("Unable to connect to server.");
   }
-  const namespace_collection = "work-orders";
-  const collection = db.collection(namespace_collection);
+  const collection = db.collection(work_orders_namespace_collection);
   async function createIndex() {
     try {
       await collection.createIndexes([
@@ -1249,17 +1302,21 @@ function useWorkOrderRepo() {
       );
     }
   }
-  const { delNamespace, setCache, getCache, delCache } = (0, import_node_server_utils7.useCache)(namespace_collection);
+  const { delNamespace, setCache, getCache, delCache } = (0, import_node_server_utils7.useCache)(
+    work_orders_namespace_collection
+  );
   const { delNamespace: _delDashboardNameSpace } = (0, import_node_server_utils7.useCache)("dashboard");
   async function createWorkOrder(value, session) {
     try {
       value = MWorkOrder(value);
       const res = await collection.insertOne(value, { session });
       delNamespace().then(() => {
-        import_node_server_utils7.logger.info(`Cache cleared for namespace: ${namespace_collection}`);
+        import_node_server_utils7.logger.info(
+          `Cache cleared for namespace: ${work_orders_namespace_collection}`
+        );
       }).catch((err) => {
         import_node_server_utils7.logger.error(
-          `Failed to clear cache for namespace: ${namespace_collection}`,
+          `Failed to clear cache for namespace: ${work_orders_namespace_collection}`,
           err
         );
       });
@@ -1326,7 +1383,10 @@ function useWorkOrderRepo() {
       query["metadata.serviceProvider"] = serviceProvider;
       cacheOptions["metadata.serviceProvider"] = serviceProvider;
     }
-    const cacheKey = (0, import_node_server_utils7.makeCacheKey)(namespace_collection, cacheOptions);
+    const cacheKey = (0, import_node_server_utils7.makeCacheKey)(
+      work_orders_namespace_collection,
+      cacheOptions
+    );
     const cachedData = await getCache(cacheKey);
     if (cachedData) {
       import_node_server_utils7.logger.info(`Cache hit for key: ${cacheKey}`);
@@ -1383,7 +1443,7 @@ function useWorkOrderRepo() {
       throw new import_node_server_utils7.BadRequestError("Invalid work order ID format.");
     }
     try {
-      const cacheKey = (0, import_node_server_utils7.makeCacheKey)(namespace_collection, {
+      const cacheKey = (0, import_node_server_utils7.makeCacheKey)(work_orders_namespace_collection, {
         _id,
         status: { $ne: "deleted" }
       });
@@ -1505,10 +1565,12 @@ function useWorkOrderRepo() {
         throw new import_node_server_utils7.InternalServerError("Unable to update work order.");
       }
       delNamespace().then(() => {
-        import_node_server_utils7.logger.info(`Cache cleared for namespace: ${namespace_collection}`);
+        import_node_server_utils7.logger.info(
+          `Cache cleared for namespace: ${work_orders_namespace_collection}`
+        );
       }).catch((err) => {
         import_node_server_utils7.logger.error(
-          `Failed to clear cache for namespace: ${namespace_collection}`,
+          `Failed to clear cache for namespace: ${work_orders_namespace_collection}`,
           err
         );
       });
@@ -1539,10 +1601,12 @@ function useWorkOrderRepo() {
         throw new import_node_server_utils7.InternalServerError("Unable to update work order status.");
       }
       delNamespace().then(() => {
-        import_node_server_utils7.logger.info(`Cache cleared for namespace: ${namespace_collection}`);
+        import_node_server_utils7.logger.info(
+          `Cache cleared for namespace: ${work_orders_namespace_collection}`
+        );
       }).catch((err) => {
         import_node_server_utils7.logger.error(
-          `Failed to clear cache for namespace: ${namespace_collection}`,
+          `Failed to clear cache for namespace: ${work_orders_namespace_collection}`,
           err
         );
       });
@@ -1568,10 +1632,12 @@ function useWorkOrderRepo() {
         session
       );
       delNamespace().then(() => {
-        import_node_server_utils7.logger.info(`Cache cleared for namespace: ${namespace_collection}`);
+        import_node_server_utils7.logger.info(
+          `Cache cleared for namespace: ${work_orders_namespace_collection}`
+        );
       }).catch((err) => {
         import_node_server_utils7.logger.error(
-          `Failed to clear cache for namespace: ${namespace_collection}`,
+          `Failed to clear cache for namespace: ${work_orders_namespace_collection}`,
           err
         );
       });
@@ -1609,10 +1675,12 @@ function useWorkOrderRepo() {
         );
       }
       delNamespace().then(() => {
-        import_node_server_utils7.logger.info(`Cache cleared for namespace: ${namespace_collection}`);
+        import_node_server_utils7.logger.info(
+          `Cache cleared for namespace: ${work_orders_namespace_collection}`
+        );
       }).catch((err) => {
         import_node_server_utils7.logger.error(
-          `Failed to clear cache for namespace: ${namespace_collection}`,
+          `Failed to clear cache for namespace: ${work_orders_namespace_collection}`,
           err
         );
       });
@@ -1647,10 +1715,12 @@ function useWorkOrderRepo() {
         throw new import_node_server_utils7.InternalServerError("Unable to delete work order.");
       }
       delNamespace().then(() => {
-        import_node_server_utils7.logger.info(`Cache cleared for namespace: ${namespace_collection}`);
+        import_node_server_utils7.logger.info(
+          `Cache cleared for namespace: ${work_orders_namespace_collection}`
+        );
       }).catch((err) => {
         import_node_server_utils7.logger.error(
-          `Failed to clear cache for namespace: ${namespace_collection}`,
+          `Failed to clear cache for namespace: ${work_orders_namespace_collection}`,
           err
         );
       });
@@ -2499,7 +2569,32 @@ function useUserRepo() {
         import_node_server_utils9.logger.info(`Cache hit for key: ${cacheKey}`);
         return cachedData;
       }
-      const data = await collection.findOne({ _id });
+      const results = await collection.aggregate([
+        { $match: { _id } },
+        {
+          $lookup: {
+            from: "site.service-providers",
+            let: { userOrgId: "$defaultOrg" },
+            pipeline: [
+              {
+                $match: {
+                  $expr: { $eq: ["$orgId", "$$userOrgId"] }
+                }
+              },
+              {
+                $project: {
+                  _id: 1,
+                  name: 1,
+                  type: 1,
+                  siteId: 1
+                }
+              }
+            ],
+            as: "serviceProviders"
+          }
+        }
+      ]).toArray();
+      const data = results.length > 0 ? results[0] : null;
       if (!data) {
         throw new import_node_server_utils9.NotFoundError("User not found.");
       }
@@ -12993,8 +13088,7 @@ var schemaVisitorTransaction = import_joi36.default.object({
   ).optional().allow(null),
   visitorPass: import_joi36.default.string().optional().allow(null, ""),
   unitName: import_joi36.default.string().optional().allow(null, ""),
-  expiredAt: import_joi36.default.date().iso().optional().allow(null, ""),
-  visitorId: import_joi36.default.string().hex().length(24).required()
+  expiredAt: import_joi36.default.date().iso().optional().allow(null, "")
 });
 var schemaUpdateVisTrans = import_joi36.default.object({
   _id: import_joi36.default.string().hex().length(24).required(),
@@ -13020,8 +13114,7 @@ var schemaUpdateVisTrans = import_joi36.default.object({
   status: import_joi36.default.string().optional().allow(null, ""),
   remarks: import_joi36.default.string().optional().allow(null, ""),
   manualCheckout: import_joi36.default.boolean().optional().allow(null),
-  expiredAt: import_joi36.default.date().iso().optional().allow(null, ""),
-  visitorId: import_joi36.default.string().hex().length(24).optional().allow(null)
+  expiredAt: import_joi36.default.date().iso().optional().allow(null, "")
 });
 function MVisitorTransaction(value) {
   const { error } = schemaVisitorTransaction.validate(value);
@@ -13092,7 +13185,6 @@ function MVisitorTransaction(value) {
     visitorPass: value.visitorPass,
     unitName: value.unitName,
     expiredAt: value.expiredAt ?? null,
-    visitorId: value.visitorId ?? "",
     createdAt: value.createdAt ?? newDate,
     updatedAt: value.updatedAt ?? "",
     deletedAt: value.deletedAt ?? ""
@@ -13101,14 +13193,16 @@ function MVisitorTransaction(value) {
 
 // src/repositories/visitor-transaction.repo.ts
 var import_mongodb39 = require("mongodb");
+var visitors_namespace_collection = "visitor.transactions";
 function useVisitorTransactionRepo() {
   const db = import_node_server_utils67.useAtlas.getDb();
   if (!db) {
     throw new import_node_server_utils67.InternalServerError("Unable to connect to server.");
   }
-  const namespace_collection = "visitor.transactions";
-  const collection = db.collection(namespace_collection);
-  const { delNamespace, getCache, setCache } = (0, import_node_server_utils67.useCache)(namespace_collection);
+  const collection = db.collection(visitors_namespace_collection);
+  const { delNamespace, getCache, setCache } = (0, import_node_server_utils67.useCache)(
+    visitors_namespace_collection
+  );
   async function createTextIndex() {
     try {
       await collection.createIndex({
@@ -13130,10 +13224,12 @@ function useVisitorTransactionRepo() {
       value = MVisitorTransaction(value);
       const res = await collection.insertOne(value, { session });
       delNamespace().then(() => {
-        import_node_server_utils67.logger.info(`Cache cleared for namespace: ${namespace_collection}`);
+        import_node_server_utils67.logger.info(
+          `Cache cleared for namespace: ${visitors_namespace_collection}`
+        );
       }).catch((err) => {
         import_node_server_utils67.logger.error(
-          `Failed to clear cache for namespace: ${namespace_collection}`,
+          `Failed to clear cache for namespace: ${visitors_namespace_collection}`,
           err
         );
       });
@@ -13208,7 +13304,7 @@ function useVisitorTransactionRepo() {
       ...checkedOut !== void 0 && { checkedOut },
       ...plateNumber && { plateNumber }
     };
-    const cacheKey = (0, import_node_server_utils67.makeCacheKey)(namespace_collection, cacheOptions);
+    const cacheKey = (0, import_node_server_utils67.makeCacheKey)(visitors_namespace_collection, cacheOptions);
     const cachedData = await getCache(cacheKey);
     if (cachedData) {
       import_node_server_utils67.logger.info(`Cache hit for key: ${cacheKey}`);
@@ -13220,6 +13316,36 @@ function useVisitorTransactionRepo() {
         collection.aggregate(
           [
             ...basePipeline,
+            {
+              $lookup: {
+                from: "access-cards",
+                localField: "_id",
+                foreignField: "userId",
+                let: { userId: "$_id" },
+                pipeline: [
+                  {
+                    $match: {
+                      $expr: {
+                        $eq: ["$userId", "$$userId"]
+                      }
+                    }
+                  },
+                  {
+                    $project: {
+                      cardNo: 1,
+                      type: 1
+                    }
+                  }
+                ],
+                as: "accessCards"
+              }
+            },
+            {
+              $unwind: {
+                path: "$accessCards",
+                preserveNullAndEmptyArrays: true
+              }
+            },
             { $sort: sort },
             { $skip: skip },
             { $limit: limit }
@@ -13242,7 +13368,7 @@ function useVisitorTransactionRepo() {
   }
   async function getOpenByPlateNumber(plateNumber, site) {
     const _site = typeof site === "string" ? site : (0, import_node_server_utils67.toObjectId)(site);
-    const cacheKey = (0, import_node_server_utils67.makeCacheKey)(namespace_collection, {
+    const cacheKey = (0, import_node_server_utils67.makeCacheKey)(visitors_namespace_collection, {
       plateNumber,
       key: "get-open-transaction-plate-number",
       site
@@ -13286,10 +13412,12 @@ function useVisitorTransactionRepo() {
         { session }
       );
       delNamespace().then(() => {
-        import_node_server_utils67.logger.info(`Cache cleared for namespace: ${namespace_collection}`);
+        import_node_server_utils67.logger.info(
+          `Cache cleared for namespace: ${visitors_namespace_collection}`
+        );
       }).catch((err) => {
         import_node_server_utils67.logger.error(
-          `Failed to clear cache for namespace: ${namespace_collection}`,
+          `Failed to clear cache for namespace: ${visitors_namespace_collection}`,
           err
         );
       });
@@ -13315,10 +13443,12 @@ function useVisitorTransactionRepo() {
         throw new import_node_server_utils67.InternalServerError("Unable to delete visitor transaction.");
       }
       delNamespace().then(() => {
-        import_node_server_utils67.logger.info(`Cache cleared for namespace: ${namespace_collection}`);
+        import_node_server_utils67.logger.info(
+          `Cache cleared for namespace: ${visitors_namespace_collection}`
+        );
       }).catch((err) => {
         import_node_server_utils67.logger.error(
-          `Failed to clear cache for namespace: ${namespace_collection}`,
+          `Failed to clear cache for namespace: ${visitors_namespace_collection}`,
           err
         );
       });
@@ -13388,10 +13518,12 @@ function useVisitorTransactionRepo() {
         { session }
       );
       delNamespace().then(() => {
-        import_node_server_utils67.logger.info(`Cache cleared for namespace: ${namespace_collection}`);
+        import_node_server_utils67.logger.info(
+          `Cache cleared for namespace: ${visitors_namespace_collection}`
+        );
       }).catch((err) => {
         import_node_server_utils67.logger.error(
-          `Failed to clear cache for namespace: ${namespace_collection}`,
+          `Failed to clear cache for namespace: ${visitors_namespace_collection}`,
           err
         );
       });
@@ -13593,14 +13725,16 @@ var import_urllib = require("urllib");
 var import_node_server_utils69 = require("@7365admin1/node-server-utils");
 var import_mongodb41 = require("mongodb");
 var import_joi38 = __toESM(require("joi"));
+var vehicles_namespace_collection = "vehicles";
 function useVehicleRepo() {
   const db = import_node_server_utils69.useAtlas.getDb();
   if (!db) {
     throw new import_node_server_utils69.InternalServerError("Unable to connect to server.");
   }
-  const namespace_collection = "vehicles";
-  const collection = db.collection(namespace_collection);
-  const { delNamespace, setCache, getCache } = (0, import_node_server_utils69.useCache)(namespace_collection);
+  const collection = db.collection(vehicles_namespace_collection);
+  const { delNamespace, setCache, getCache } = (0, import_node_server_utils69.useCache)(
+    vehicles_namespace_collection
+  );
   async function createIndex() {
     try {
       await collection.createIndexes([
@@ -13633,10 +13767,12 @@ function useVehicleRepo() {
       value = MVehicle(value);
       const res = await collection.insertOne(value, { session });
       delNamespace().then(() => {
-        import_node_server_utils69.logger.info(`Cache cleared for namespace: ${namespace_collection}`);
+        import_node_server_utils69.logger.info(
+          `Cache cleared for namespace: ${vehicles_namespace_collection}`
+        );
       }).catch((err) => {
         import_node_server_utils69.logger.error(
-          `Failed to clear cache for namespace: ${namespace_collection}`,
+          `Failed to clear cache for namespace: ${vehicles_namespace_collection}`,
           err
         );
       });
@@ -13682,7 +13818,7 @@ function useVehicleRepo() {
       query.$text = { $search: search };
       cacheOptions.search = search;
     }
-    const cacheKey = (0, import_node_server_utils69.makeCacheKey)(namespace_collection, cacheOptions);
+    const cacheKey = (0, import_node_server_utils69.makeCacheKey)(vehicles_namespace_collection, cacheOptions);
     const cachedData = await getCache(cacheKey);
     if (cachedData) {
       import_node_server_utils69.logger.info(`Cache hit for key: ${cacheKey}`);
@@ -13846,7 +13982,7 @@ function useVehicleRepo() {
     } catch (error) {
       throw new import_node_server_utils69.BadRequestError("Invalid site ID format.");
     }
-    const cacheKey = (0, import_node_server_utils69.makeCacheKey)(namespace_collection, {
+    const cacheKey = (0, import_node_server_utils69.makeCacheKey)(vehicles_namespace_collection, {
       site,
       type: "season-pass-type-as-options"
     });
@@ -13899,7 +14035,7 @@ function useVehicleRepo() {
       throw new import_node_server_utils69.BadRequestError("Invalid vehicle ID format.");
     }
     try {
-      const cacheKey = (0, import_node_server_utils69.makeCacheKey)(namespace_collection, { _id });
+      const cacheKey = (0, import_node_server_utils69.makeCacheKey)(vehicles_namespace_collection, { _id });
       const cachedData = await getCache(cacheKey);
       if (cachedData) {
         import_node_server_utils69.logger.info(`Cache hit for key: ${cacheKey}`);
@@ -14090,7 +14226,7 @@ function useVehicleRepo() {
       throw new import_node_server_utils69.BadRequestError(error.details[0].message);
     }
     try {
-      const cacheKey = (0, import_node_server_utils69.makeCacheKey)(namespace_collection, {
+      const cacheKey = (0, import_node_server_utils69.makeCacheKey)(vehicles_namespace_collection, {
         plateNumber: value,
         status: "active"
       });
@@ -14136,10 +14272,12 @@ function useVehicleRepo() {
         throw new import_node_server_utils69.InternalServerError("Unable to update vehicle.");
       }
       delNamespace().then(() => {
-        import_node_server_utils69.logger.info(`Cache cleared for namespace: ${namespace_collection}`);
+        import_node_server_utils69.logger.info(
+          `Cache cleared for namespace: ${vehicles_namespace_collection}`
+        );
       }).catch((err) => {
         import_node_server_utils69.logger.error(
-          `Failed to clear cache for namespace: ${namespace_collection}`,
+          `Failed to clear cache for namespace: ${vehicles_namespace_collection}`,
           err
         );
       });
@@ -14167,10 +14305,12 @@ function useVehicleRepo() {
       if (res.modifiedCount === 0)
         throw new import_node_server_utils69.InternalServerError("Unable to delete vehicle.");
       delNamespace().then(() => {
-        import_node_server_utils69.logger.info(`Cache cleared for namespace: ${namespace_collection}`);
+        import_node_server_utils69.logger.info(
+          `Cache cleared for namespace: ${vehicles_namespace_collection}`
+        );
       }).catch((err) => {
         import_node_server_utils69.logger.error(
-          `Failed to clear cache for namespace: ${namespace_collection}`,
+          `Failed to clear cache for namespace: ${vehicles_namespace_collection}`,
           err
         );
       });
@@ -14184,7 +14324,7 @@ function useVehicleRepo() {
     if (error) {
       throw new import_node_server_utils69.BadRequestError(error.details[0].message);
     }
-    const cacheKey = (0, import_node_server_utils69.makeCacheKey)(namespace_collection, {
+    const cacheKey = (0, import_node_server_utils69.makeCacheKey)(vehicles_namespace_collection, {
       plateNumber,
       status: "active"
     });
@@ -14233,7 +14373,7 @@ function useVehicleRepo() {
       limit: String(limit),
       sort: JSON.stringify(sort)
     };
-    const cacheKey = (0, import_node_server_utils69.makeCacheKey)(namespace_collection, cacheOptions);
+    const cacheKey = (0, import_node_server_utils69.makeCacheKey)(vehicles_namespace_collection, cacheOptions);
     const cachedData = await getCache(cacheKey);
     if (cachedData) {
       import_node_server_utils69.logger.info(`Cache hit for key: ${cacheKey}`);
@@ -14280,10 +14420,12 @@ function useVehicleRepo() {
         { session }
       );
       delNamespace().then(() => {
-        import_node_server_utils69.logger.info(`Cache cleared for namespace: ${namespace_collection}`);
+        import_node_server_utils69.logger.info(
+          `Cache cleared for namespace: ${vehicles_namespace_collection}`
+        );
       }).catch((err) => {
         import_node_server_utils69.logger.error(
-          `Failed to clear cache for namespace: ${namespace_collection}`,
+          `Failed to clear cache for namespace: ${vehicles_namespace_collection}`,
           err
         );
       });
@@ -14311,7 +14453,10 @@ function useVehicleRepo() {
         limit,
         sort: JSON.stringify(sort)
       };
-      const cacheKey = (0, import_node_server_utils69.makeCacheKey)(namespace_collection, cacheOptions);
+      const cacheKey = (0, import_node_server_utils69.makeCacheKey)(
+        vehicles_namespace_collection,
+        cacheOptions
+      );
       const cachedData = await getCache(cacheKey);
       if (cachedData) {
         import_node_server_utils69.logger.info(`Cache hit for key: ${cacheKey}`);
@@ -14360,14 +14505,16 @@ var import_node_server_utils71 = require("@7365admin1/node-server-utils");
 // src/repositories/person.repo.ts
 var import_node_server_utils70 = require("@7365admin1/node-server-utils");
 var import_mongodb42 = require("mongodb");
+var site_people_namespace_collection = "site.people";
 function usePersonRepo() {
   const db = import_node_server_utils70.useAtlas.getDb();
   if (!db) {
     throw new import_node_server_utils70.InternalServerError("Unable to connect to server.");
   }
-  const namespace_collection = "site.people";
-  const collection = db.collection(namespace_collection);
-  const { delNamespace, getCache, setCache } = (0, import_node_server_utils70.useCache)(namespace_collection);
+  const collection = db.collection(site_people_namespace_collection);
+  const { delNamespace, getCache, setCache } = (0, import_node_server_utils70.useCache)(
+    site_people_namespace_collection
+  );
   async function createIndexes() {
     try {
       await collection.createIndexes([
@@ -14399,10 +14546,12 @@ function usePersonRepo() {
       value = MPerson(value);
       const res = await collection.insertOne(value, { session });
       delNamespace().then(() => {
-        import_node_server_utils70.logger.info(`Cache cleared for namespace: ${namespace_collection}`);
+        import_node_server_utils70.logger.info(
+          `Cache cleared for namespace: ${site_people_namespace_collection}`
+        );
       }).catch((err) => {
         import_node_server_utils70.logger.error(
-          `Failed to clear cache for namespace: ${namespace_collection}`,
+          `Failed to clear cache for namespace: ${site_people_namespace_collection}`,
           err
         );
       });
@@ -14464,7 +14613,10 @@ function usePersonRepo() {
       ...query.site && { site: query.site.toString() },
       ...PERSON_TYPES.includes(type) && { type }
     };
-    const cacheKey = (0, import_node_server_utils70.makeCacheKey)(namespace_collection, cacheOptions);
+    const cacheKey = (0, import_node_server_utils70.makeCacheKey)(
+      site_people_namespace_collection,
+      cacheOptions
+    );
     const cachedData = await getCache(cacheKey);
     if (cachedData) {
       import_node_server_utils70.logger.info(`Cache hit for key: ${cacheKey}`);
@@ -14505,10 +14657,12 @@ function usePersonRepo() {
         { session }
       );
       delNamespace().then(() => {
-        import_node_server_utils70.logger.info(`Cache cleared for namespace: ${namespace_collection}`);
+        import_node_server_utils70.logger.info(
+          `Cache cleared for namespace: ${site_people_namespace_collection}`
+        );
       }).catch((err) => {
         import_node_server_utils70.logger.error(
-          `Failed to clear cache for namespace: ${namespace_collection}`,
+          `Failed to clear cache for namespace: ${site_people_namespace_collection}`,
           err
         );
       });
@@ -14534,10 +14688,12 @@ function usePersonRepo() {
         throw new import_node_server_utils70.InternalServerError("Unable to delete visitor transaction.");
       }
       delNamespace().then(() => {
-        import_node_server_utils70.logger.info(`Cache cleared for namespace: ${namespace_collection}`);
+        import_node_server_utils70.logger.info(
+          `Cache cleared for namespace: ${site_people_namespace_collection}`
+        );
       }).catch((err) => {
         import_node_server_utils70.logger.error(
-          `Failed to clear cache for namespace: ${namespace_collection}`,
+          `Failed to clear cache for namespace: ${site_people_namespace_collection}`,
           err
         );
       });
@@ -14552,7 +14708,7 @@ function usePersonRepo() {
     } catch (error) {
       throw new import_node_server_utils70.BadRequestError("Invalid person ID.");
     }
-    const cacheKey = (0, import_node_server_utils70.makeCacheKey)(namespace_collection, {
+    const cacheKey = (0, import_node_server_utils70.makeCacheKey)(site_people_namespace_collection, {
       _id: String(_id)
     });
     try {
@@ -14588,7 +14744,7 @@ function usePersonRepo() {
     }
   }
   async function getPersonByPlateNumber(plateNumber) {
-    const cacheKey = (0, import_node_server_utils70.makeCacheKey)(namespace_collection, {
+    const cacheKey = (0, import_node_server_utils70.makeCacheKey)(site_people_namespace_collection, {
       plateNumber,
       key: "get-person-plate-number"
     });
@@ -14616,7 +14772,7 @@ function usePersonRepo() {
   }
   async function getByNRIC(value) {
     try {
-      const cacheKey = (0, import_node_server_utils70.makeCacheKey)(namespace_collection, {
+      const cacheKey = (0, import_node_server_utils70.makeCacheKey)(site_people_namespace_collection, {
         nric: value
       });
       const cachedData = await getCache(cacheKey);
@@ -14637,7 +14793,7 @@ function usePersonRepo() {
   }
   async function getPersonByPhoneNumber(value) {
     try {
-      const cacheKey = (0, import_node_server_utils70.makeCacheKey)(namespace_collection, {
+      const cacheKey = (0, import_node_server_utils70.makeCacheKey)(site_people_namespace_collection, {
         contact: value
       });
       const cachedData = await getCache(cacheKey);
@@ -14663,7 +14819,7 @@ function usePersonRepo() {
     type,
     unit
   }, session) {
-    const cacheKey = (0, import_node_server_utils70.makeCacheKey)(namespace_collection, {
+    const cacheKey = (0, import_node_server_utils70.makeCacheKey)(site_people_namespace_collection, {
       unit: JSON.stringify(unit),
       status,
       type,
@@ -14690,7 +14846,7 @@ function usePersonRepo() {
   }
   async function getCompany(search) {
     try {
-      const cacheKey = (0, import_node_server_utils70.makeCacheKey)(namespace_collection, {
+      const cacheKey = (0, import_node_server_utils70.makeCacheKey)(site_people_namespace_collection, {
         company: search
       });
       const cachedData = await getCache(cacheKey);
@@ -14749,7 +14905,7 @@ function usePersonRepo() {
     }
   }
   async function getPeopleByPlateNumber(plateNumber) {
-    const cacheKey = (0, import_node_server_utils70.makeCacheKey)(namespace_collection, {
+    const cacheKey = (0, import_node_server_utils70.makeCacheKey)(site_people_namespace_collection, {
       plateNumber,
       key: "get-people-plate-number"
     });
@@ -14795,7 +14951,10 @@ function usePersonRepo() {
       sort: JSON.stringify(sort)
     };
     try {
-      const cacheKey = (0, import_node_server_utils70.makeCacheKey)(namespace_collection, cacheOptions);
+      const cacheKey = (0, import_node_server_utils70.makeCacheKey)(
+        site_people_namespace_collection,
+        cacheOptions
+      );
       const cachedData = await getCache(cacheKey);
       if (cachedData) {
         import_node_server_utils70.logger.info(`Cache hit for key: ${cacheKey}`);
@@ -16587,14 +16746,16 @@ function MBuildingUnit(value) {
 // src/repositories/building.repository.ts
 var import_node_server_utils79 = require("@7365admin1/node-server-utils");
 var import_mongodb46 = require("mongodb");
+var buildings_namespace_collection = "buildings";
 function useBuildingRepo() {
   const db = import_node_server_utils79.useAtlas.getDb();
   if (!db) {
     throw new Error("Unable to connect to server.");
   }
-  const namespace_collection = "buildings";
-  const collection = db.collection(namespace_collection);
-  const { getCache, setCache, delNamespace } = (0, import_node_server_utils79.useCache)(namespace_collection);
+  const collection = db.collection(buildings_namespace_collection);
+  const { getCache, setCache, delNamespace } = (0, import_node_server_utils79.useCache)(
+    buildings_namespace_collection
+  );
   async function createIndexes() {
     try {
       await collection.createIndexes([
@@ -16703,7 +16864,7 @@ function useBuildingRepo() {
       ...site && { site },
       ...status && { status }
     };
-    const cacheKey = (0, import_node_server_utils79.makeCacheKey)(namespace_collection, cacheParams);
+    const cacheKey = (0, import_node_server_utils79.makeCacheKey)(buildings_namespace_collection, cacheParams);
     import_node_server_utils79.logger.log({
       level: "info",
       message: `Cache key for getAll buildings: ${cacheKey}`
@@ -16748,7 +16909,9 @@ function useBuildingRepo() {
     } catch (error) {
       throw new import_node_server_utils79.BadRequestError("Invalid ID.");
     }
-    const cacheKey = (0, import_node_server_utils79.makeCacheKey)(namespace_collection, { _id: String(_id) });
+    const cacheKey = (0, import_node_server_utils79.makeCacheKey)(buildings_namespace_collection, {
+      _id: String(_id)
+    });
     try {
       const cached = await getCache(cacheKey);
       if (cached) {
@@ -16817,7 +16980,7 @@ function useBuildingRepo() {
       block
     };
     const cacheOptions = { ...query };
-    const cacheKey = (0, import_node_server_utils79.makeCacheKey)(namespace_collection, cacheOptions);
+    const cacheKey = (0, import_node_server_utils79.makeCacheKey)(buildings_namespace_collection, cacheOptions);
     try {
       const cached = await getCache(cacheKey);
       if (cached) {
@@ -16852,12 +17015,12 @@ function useBuildingRepo() {
     delNamespace().then(() => {
       import_node_server_utils79.logger.log({
         level: "info",
-        message: `Cache namespace cleared for ${namespace_collection}`
+        message: `Cache namespace cleared for ${buildings_namespace_collection}`
       });
     }).catch((err) => {
       import_node_server_utils79.logger.log({
         level: "error",
-        message: `Failed to clear cache namespace for ${namespace_collection}: ${err.message}`
+        message: `Failed to clear cache namespace for ${buildings_namespace_collection}: ${err.message}`
       });
     });
   }
@@ -20262,9 +20425,9 @@ function useVisitorTransactionService() {
         value.checkIn = startString;
         value.expiredAt = endString;
       }
-      await _add(value, session);
+      const result = await _add(value, session);
       await session?.commitTransaction();
-      return "Successfully added visitor transaction.";
+      return result;
     } catch (error) {
       await session?.abortTransaction();
       throw error;
@@ -20609,14 +20772,16 @@ function MGuestManagement(value) {
 // src/repositories/guest-management.repo.ts
 var import_node_server_utils101 = require("@7365admin1/node-server-utils");
 var import_mongodb55 = require("mongodb");
+var guests_namespace_collection = "visitor.guests";
 function useGuestManagementRepo() {
   const db = import_node_server_utils101.useAtlas.getDb();
   if (!db) {
     throw new import_node_server_utils101.InternalServerError("Unable to connect to server.");
   }
-  const namespace_collection = "visitor.guests";
-  const collection = db.collection(namespace_collection);
-  const { delNamespace, getCache, setCache } = (0, import_node_server_utils101.useCache)(namespace_collection);
+  const collection = db.collection(guests_namespace_collection);
+  const { delNamespace, getCache, setCache } = (0, import_node_server_utils101.useCache)(
+    guests_namespace_collection
+  );
   async function createTextIndex() {
     try {
       await collection.createIndex({
@@ -20636,10 +20801,12 @@ function useGuestManagementRepo() {
       value = MGuestManagement(value);
       const res = await collection.insertOne(value, { session });
       delNamespace().then(() => {
-        import_node_server_utils101.logger.info(`Cache cleared for namespace: ${namespace_collection}`);
+        import_node_server_utils101.logger.info(
+          `Cache cleared for namespace: ${guests_namespace_collection}`
+        );
       }).catch((err) => {
         import_node_server_utils101.logger.error(
-          `Failed to clear cache for namespace: ${namespace_collection}`,
+          `Failed to clear cache for namespace: ${guests_namespace_collection}`,
           err
         );
       });
@@ -20691,7 +20858,7 @@ function useGuestManagementRepo() {
       ...query.org && { org: query.org.toString() },
       ...query.site && { site: query.site.toString() }
     };
-    const cacheKey = (0, import_node_server_utils101.makeCacheKey)(namespace_collection, cacheOptions);
+    const cacheKey = (0, import_node_server_utils101.makeCacheKey)(guests_namespace_collection, cacheOptions);
     const cachedData = await getCache(cacheKey);
     if (cachedData) {
       import_node_server_utils101.logger.info(`Cache hit for key: ${cacheKey}`);
@@ -20732,10 +20899,12 @@ function useGuestManagementRepo() {
         { session }
       );
       delNamespace().then(() => {
-        import_node_server_utils101.logger.info(`Cache cleared for namespace: ${namespace_collection}`);
+        import_node_server_utils101.logger.info(
+          `Cache cleared for namespace: ${guests_namespace_collection}`
+        );
       }).catch((err) => {
         import_node_server_utils101.logger.error(
-          `Failed to clear cache for namespace: ${namespace_collection}`,
+          `Failed to clear cache for namespace: ${guests_namespace_collection}`,
           err
         );
       });
@@ -20761,10 +20930,12 @@ function useGuestManagementRepo() {
         throw new import_node_server_utils101.InternalServerError("Unable to delete visitor transaction.");
       }
       delNamespace().then(() => {
-        import_node_server_utils101.logger.info(`Cache cleared for namespace: ${namespace_collection}`);
+        import_node_server_utils101.logger.info(
+          `Cache cleared for namespace: ${guests_namespace_collection}`
+        );
       }).catch((err) => {
         import_node_server_utils101.logger.error(
-          `Failed to clear cache for namespace: ${namespace_collection}`,
+          `Failed to clear cache for namespace: ${guests_namespace_collection}`,
           err
         );
       });
@@ -24995,14 +25166,16 @@ function MSiteFacilityBooking(value) {
 // src/repositories/site-facility-booking.repo.ts
 var import_node_server_utils126 = require("@7365admin1/node-server-utils");
 var import_mongodb69 = require("mongodb");
+var facility_bookings_namespace_collection = "site.facilty-booking";
 function useSiteFacilityBookingRepo() {
   const db = import_node_server_utils126.useAtlas.getDb();
   if (!db) {
     throw new import_node_server_utils126.InternalServerError("Unable to connect to server.");
   }
-  const namespace_collection = "site.facilty-booking";
-  const collection = db.collection(namespace_collection);
-  const { delNamespace, getCache, setCache } = (0, import_node_server_utils126.useCache)(namespace_collection);
+  const collection = db.collection(facility_bookings_namespace_collection);
+  const { delNamespace, getCache, setCache } = (0, import_node_server_utils126.useCache)(
+    facility_bookings_namespace_collection
+  );
   async function createIndexes() {
     try {
       await collection.createIndexes([{ key: { site: 1, status: 1 } }]);
@@ -25015,10 +25188,12 @@ function useSiteFacilityBookingRepo() {
       value = MSiteFacilityBooking(value);
       const res = await collection.insertOne(value, { session });
       delNamespace().then(() => {
-        import_node_server_utils126.logger.info(`Cache cleared for namespace: ${namespace_collection}`);
+        import_node_server_utils126.logger.info(
+          `Cache cleared for namespace: ${facility_bookings_namespace_collection}`
+        );
       }).catch((err) => {
         import_node_server_utils126.logger.error(
-          `Failed to clear cache for namespace: ${namespace_collection}`,
+          `Failed to clear cache for namespace: ${facility_bookings_namespace_collection}`,
           err
         );
       });
@@ -25056,7 +25231,10 @@ function useSiteFacilityBookingRepo() {
       limit,
       ...search && { search }
     };
-    const cacheKey = (0, import_node_server_utils126.makeCacheKey)(namespace_collection, cacheOptions);
+    const cacheKey = (0, import_node_server_utils126.makeCacheKey)(
+      facility_bookings_namespace_collection,
+      cacheOptions
+    );
     const cachedData = await getCache(cacheKey);
     if (cachedData) {
       import_node_server_utils126.logger.info(`Cache hit for key: ${cacheKey}`);
@@ -25086,7 +25264,9 @@ function useSiteFacilityBookingRepo() {
   }
   async function getSiteFacilityBookingById(id, session) {
     const _id = (0, import_node_server_utils126.toObjectId)(id);
-    const cacheKey = (0, import_node_server_utils126.makeCacheKey)(namespace_collection, { id });
+    const cacheKey = (0, import_node_server_utils126.makeCacheKey)(facility_bookings_namespace_collection, {
+      id
+    });
     const cachedData = await getCache(cacheKey);
     if (cachedData) {
       import_node_server_utils126.logger.info(`Cache hit for key: ${cacheKey}`);
@@ -25132,10 +25312,12 @@ function useSiteFacilityBookingRepo() {
         );
       }
       delNamespace().then(() => {
-        import_node_server_utils126.logger.info(`Cache cleared for namespace: ${namespace_collection}`);
+        import_node_server_utils126.logger.info(
+          `Cache cleared for namespace: ${facility_bookings_namespace_collection}`
+        );
       }).catch((err) => {
         import_node_server_utils126.logger.error(
-          `Failed to clear cache for namespace: ${namespace_collection}`,
+          `Failed to clear cache for namespace: ${facility_bookings_namespace_collection}`,
           err
         );
       });
@@ -25163,10 +25345,12 @@ function useSiteFacilityBookingRepo() {
         );
       }
       delNamespace().then(() => {
-        import_node_server_utils126.logger.info(`Cache cleared for namespace: ${namespace_collection}`);
+        import_node_server_utils126.logger.info(
+          `Cache cleared for namespace: ${facility_bookings_namespace_collection}`
+        );
       }).catch((err) => {
         import_node_server_utils126.logger.error(
-          `Failed to clear cache for namespace: ${namespace_collection}`,
+          `Failed to clear cache for namespace: ${facility_bookings_namespace_collection}`,
           err
         );
       });
@@ -26084,14 +26268,16 @@ function MBulletinBoard(value) {
 // src/repositories/bulletin-board.repo.ts
 var import_node_server_utils132 = require("@7365admin1/node-server-utils");
 var import_mongodb73 = require("mongodb");
+var bulletin_boards_namespace_collection = "bulletin-boards";
 function useBulletinBoardRepo() {
   const db = import_node_server_utils132.useAtlas.getDb();
   if (!db) {
     throw new import_node_server_utils132.InternalServerError("Unable to connect to server.");
   }
-  const namespace_collection = "bulletin-boards";
-  const collection = db.collection(namespace_collection);
-  const { delNamespace, getCache, setCache } = (0, import_node_server_utils132.useCache)(namespace_collection);
+  const collection = db.collection(bulletin_boards_namespace_collection);
+  const { delNamespace, getCache, setCache } = (0, import_node_server_utils132.useCache)(
+    bulletin_boards_namespace_collection
+  );
   async function createIndexes() {
     try {
       await collection.createIndexes([{ key: { site: 1, status: 1 } }]);
@@ -26104,10 +26290,12 @@ function useBulletinBoardRepo() {
       value = MBulletinBoard(value);
       const res = await collection.insertOne(value, { session });
       delNamespace().then(() => {
-        import_node_server_utils132.logger.info(`Cache cleared for namespace: ${namespace_collection}`);
+        import_node_server_utils132.logger.info(
+          `Cache cleared for namespace: ${bulletin_boards_namespace_collection}`
+        );
       }).catch((err) => {
         import_node_server_utils132.logger.error(
-          `Failed to clear cache for namespace: ${namespace_collection}`,
+          `Failed to clear cache for namespace: ${bulletin_boards_namespace_collection}`,
           err
         );
       });
@@ -26151,7 +26339,10 @@ function useBulletinBoardRepo() {
       ...search && { search },
       ...recipients?.length && { recipients: recipients.sort().join(",") }
     };
-    const cacheKey = (0, import_node_server_utils132.makeCacheKey)(namespace_collection, cacheOptions);
+    const cacheKey = (0, import_node_server_utils132.makeCacheKey)(
+      bulletin_boards_namespace_collection,
+      cacheOptions
+    );
     const cachedData = await getCache(cacheKey);
     if (cachedData) {
       import_node_server_utils132.logger.info(`Cache hit for key: ${cacheKey}`);
@@ -26185,7 +26376,9 @@ function useBulletinBoardRepo() {
     } catch (error) {
       throw new import_node_server_utils132.BadRequestError("Invalid bulletin board ID format.");
     }
-    const cacheKey = (0, import_node_server_utils132.makeCacheKey)(namespace_collection, { _id });
+    const cacheKey = (0, import_node_server_utils132.makeCacheKey)(bulletin_boards_namespace_collection, {
+      _id
+    });
     const cachedData = await getCache(cacheKey);
     if (cachedData) {
       import_node_server_utils132.logger.info(`Cache hit for key: ${cacheKey}`);
@@ -26230,10 +26423,12 @@ function useBulletinBoardRepo() {
         throw new import_node_server_utils132.InternalServerError("Unable to update bulletin board.");
       }
       delNamespace().then(() => {
-        import_node_server_utils132.logger.info(`Cache cleared for namespace: ${namespace_collection}`);
+        import_node_server_utils132.logger.info(
+          `Cache cleared for namespace: ${bulletin_boards_namespace_collection}`
+        );
       }).catch((err) => {
         import_node_server_utils132.logger.error(
-          `Failed to clear cache for namespace: ${namespace_collection}`,
+          `Failed to clear cache for namespace: ${bulletin_boards_namespace_collection}`,
           err
         );
       });
@@ -26263,10 +26458,12 @@ function useBulletinBoardRepo() {
         throw new import_node_server_utils132.InternalServerError("Unable to delete bulletin board.");
       }
       delNamespace().then(() => {
-        import_node_server_utils132.logger.info(`Cache cleared for namespace: ${namespace_collection}`);
+        import_node_server_utils132.logger.info(
+          `Cache cleared for namespace: ${bulletin_boards_namespace_collection}`
+        );
       }).catch((err) => {
         import_node_server_utils132.logger.error(
-          `Failed to clear cache for namespace: ${namespace_collection}`,
+          `Failed to clear cache for namespace: ${bulletin_boards_namespace_collection}`,
           err
         );
       });
@@ -26295,10 +26492,12 @@ function useBulletinBoardRepo() {
         throw new import_node_server_utils132.NotFoundError("No bulletin boards found to update.");
       }
       delNamespace().then(() => {
-        import_node_server_utils132.logger.info(`Cache cleared for namespace: ${namespace_collection}`);
+        import_node_server_utils132.logger.info(
+          `Cache cleared for namespace: ${bulletin_boards_namespace_collection}`
+        );
       }).catch((err) => {
         import_node_server_utils132.logger.error(
-          `Failed to clear cache for namespace: ${namespace_collection}`,
+          `Failed to clear cache for namespace: ${bulletin_boards_namespace_collection}`,
           err
         );
       });
@@ -26438,7 +26637,32 @@ function useBulletinBoardController() {
       order: import_joi76.default.string().valid(...Object.values(SortOrder)).default("asc" /* ASC */),
       site: import_joi76.default.string().hex().length(24).required(),
       status: import_joi76.default.string().valid(...Object.values(BuildingStatus)).optional().default("active" /* ACTIVE */),
-      recipients: import_joi76.default.array().items(import_joi76.default.string().valid(...Object.values(BulletinRecipient))).optional()
+      recipients: import_joi76.default.alternatives().try(
+        import_joi76.default.array().items(
+          import_joi76.default.string().valid(...Object.values(BulletinRecipient))
+        ),
+        import_joi76.default.string().allow("")
+      ).optional().allow(null).custom((value2, helpers) => {
+        if (!value2 || value2 === "") {
+          return [];
+        }
+        let parsed = [];
+        if (Array.isArray(value2)) {
+          parsed = value2;
+        } else if (typeof value2 === "string") {
+          parsed = value2.split(",").map((v) => v.trim()).filter(Boolean);
+        }
+        for (const r of parsed) {
+          if (!Object.values(BulletinRecipient).includes(r)) {
+            return helpers.error("any.only");
+          }
+        }
+        return parsed;
+      }).messages({
+        "any.only": `Recipients must be one of: ${Object.values(
+          BulletinRecipient
+        ).join(", ")}`
+      })
     });
     const { error, value } = validation.validate(req.query, {
       abortEarly: false
@@ -27836,14 +28060,16 @@ function MEventManagement(value) {
 // src/repositories/event-management.repo.ts
 var import_node_server_utils143 = require("@7365admin1/node-server-utils");
 var import_mongodb79 = require("mongodb");
+var events_namespace_collection = "event-management";
 function useEventManagementRepo() {
   const db = import_node_server_utils143.useAtlas.getDb();
   if (!db) {
     throw new import_node_server_utils143.InternalServerError("Unable to connect to server.");
   }
-  const namespace_collection = "event-management";
-  const collection = db.collection(namespace_collection);
-  const { delNamespace, getCache, setCache } = (0, import_node_server_utils143.useCache)(namespace_collection);
+  const collection = db.collection(events_namespace_collection);
+  const { delNamespace, getCache, setCache } = (0, import_node_server_utils143.useCache)(
+    events_namespace_collection
+  );
   async function createIndexes() {
     try {
       await collection.createIndexes([{ key: { site: 1, status: 1 } }]);
@@ -27870,10 +28096,12 @@ function useEventManagementRepo() {
       value = MEventManagement(value);
       const res = await collection.insertOne(value, { session });
       delNamespace().then(() => {
-        import_node_server_utils143.logger.info(`Cache cleared for namespace: ${namespace_collection}`);
+        import_node_server_utils143.logger.info(
+          `Cache cleared for namespace: ${events_namespace_collection}`
+        );
       }).catch((err) => {
         import_node_server_utils143.logger.error(
-          `Failed to clear cache for namespace: ${namespace_collection}`,
+          `Failed to clear cache for namespace: ${events_namespace_collection}`,
           err
         );
       });
@@ -27927,7 +28155,7 @@ function useEventManagementRepo() {
       query.$text = { $search: search };
       cacheOptions.search = search;
     }
-    const cacheKey = (0, import_node_server_utils143.makeCacheKey)(namespace_collection, cacheOptions);
+    const cacheKey = (0, import_node_server_utils143.makeCacheKey)(events_namespace_collection, cacheOptions);
     const cachedData = await getCache(cacheKey);
     if (cachedData) {
       import_node_server_utils143.logger.info(`Cache hit for key: ${cacheKey}`);
@@ -27979,7 +28207,7 @@ function useEventManagementRepo() {
     } catch (error) {
       throw new import_node_server_utils143.BadRequestError("Invalid event ID format.");
     }
-    const cacheKey = (0, import_node_server_utils143.makeCacheKey)(namespace_collection, { _id });
+    const cacheKey = (0, import_node_server_utils143.makeCacheKey)(events_namespace_collection, { _id });
     const cachedData = await getCache(cacheKey);
     if (cachedData) {
       import_node_server_utils143.logger.info(`Cache hit for key: ${cacheKey}`);
@@ -28024,10 +28252,12 @@ function useEventManagementRepo() {
         throw new import_node_server_utils143.InternalServerError("Unable to update event.");
       }
       delNamespace().then(() => {
-        import_node_server_utils143.logger.info(`Cache cleared for namespace: ${namespace_collection}`);
+        import_node_server_utils143.logger.info(
+          `Cache cleared for namespace: ${events_namespace_collection}`
+        );
       }).catch((err) => {
         import_node_server_utils143.logger.error(
-          `Failed to clear cache for namespace: ${namespace_collection}`,
+          `Failed to clear cache for namespace: ${events_namespace_collection}`,
           err
         );
       });
@@ -28053,10 +28283,12 @@ function useEventManagementRepo() {
         throw new import_node_server_utils143.InternalServerError("Unable to delete event.");
       }
       delNamespace().then(() => {
-        import_node_server_utils143.logger.info(`Cache cleared for namespace: ${namespace_collection}`);
+        import_node_server_utils143.logger.info(
+          `Cache cleared for namespace: ${events_namespace_collection}`
+        );
       }).catch((err) => {
         import_node_server_utils143.logger.error(
-          `Failed to clear cache for namespace: ${namespace_collection}`,
+          `Failed to clear cache for namespace: ${events_namespace_collection}`,
           err
         );
       });
@@ -28085,10 +28317,12 @@ function useEventManagementRepo() {
         throw new import_node_server_utils143.NotFoundError("No bulletin boards found to update.");
       }
       delNamespace().then(() => {
-        import_node_server_utils143.logger.info(`Cache cleared for namespace: ${namespace_collection}`);
+        import_node_server_utils143.logger.info(
+          `Cache cleared for namespace: ${events_namespace_collection}`
+        );
       }).catch((err) => {
         import_node_server_utils143.logger.error(
-          `Failed to clear cache for namespace: ${namespace_collection}`,
+          `Failed to clear cache for namespace: ${events_namespace_collection}`,
           err
         );
       });
@@ -31326,6 +31560,21 @@ function UseAccessManagementRepo() {
       throw new Error(error.message);
     }
   }
+  async function checkoutVisitorRepo(params) {
+    const session = import_node_server_utils150.useAtlas.getClient()?.startSession();
+    try {
+      await session?.startTransaction();
+      const userId = new import_mongodb84.ObjectId(params.userId);
+      const result = await collection().updateMany({ userId }, { $set: { userId: null, status: "Available", updatedAt: /* @__PURE__ */ new Date() } });
+      await session?.commitTransaction();
+      return result;
+    } catch (error) {
+      await session?.abortTransaction();
+      throw new Error(error.message);
+    } finally {
+      await session?.endSession();
+    }
+  }
   return {
     createIndexes,
     createIndexForEntrypass,
@@ -31354,7 +31603,8 @@ function UseAccessManagementRepo() {
     availableCardContractorsRepo,
     vmsgenerateQrCodesRepo,
     addVisitorAccessCardRepo,
-    signQrCodeRepo
+    signQrCodeRepo,
+    checkoutVisitorRepo
   };
 }
 
@@ -31392,7 +31642,8 @@ function useAccessManagementSvc() {
     availableCardContractorsRepo,
     vmsgenerateQrCodesRepo,
     addVisitorAccessCardRepo,
-    signQrCodeRepo
+    signQrCodeRepo,
+    checkoutVisitorRepo
   } = UseAccessManagementRepo();
   const addPhysicalCardSvc = async (payload) => {
     try {
@@ -31668,6 +31919,14 @@ function useAccessManagementSvc() {
       throw new Error(err.message);
     }
   };
+  const checkoutVisitorSvc = async (params) => {
+    try {
+      const response = await checkoutVisitorRepo({ ...params });
+      return response;
+    } catch (err) {
+      throw new Error(err.message);
+    }
+  };
   return {
     addPhysicalCardSvc,
     addNonPhysicalCardSvc,
@@ -31700,7 +31959,8 @@ function useAccessManagementSvc() {
     availableCardContractorsSvc,
     vmsgenerateQrCodesSvc,
     addVisitorAccessCardSvc,
-    signQrCodeSvc
+    signQrCodeSvc,
+    checkoutVisitorSvc
   };
 }
 
@@ -31738,7 +31998,8 @@ function useAccessManagementController() {
     availableCardContractorsSvc,
     vmsgenerateQrCodesSvc,
     addVisitorAccessCardSvc,
-    signQrCodeSvc
+    signQrCodeSvc,
+    checkoutVisitorSvc
   } = useAccessManagementSvc();
   const addPhysicalCard = async (req, res) => {
     try {
@@ -32463,6 +32724,25 @@ function useAccessManagementController() {
       });
     }
   };
+  const checkoutVisitor = async (req, res) => {
+    try {
+      const { userId } = req.body;
+      const schema2 = import_joi85.default.object({
+        userId: import_joi85.default.string().hex().length(24).required()
+      });
+      const { error } = schema2.validate({ userId });
+      if (error) {
+        return res.status(400).json({ message: error.message });
+      }
+      const result = await checkoutVisitorSvc({ userId });
+      return res.status(200).json({ message: "Success", data: result });
+    } catch (error) {
+      return res.status(500).json({
+        data: null,
+        message: error.message
+      });
+    }
+  };
   return {
     addPhysicalCard,
     addNonPhysicalCard,
@@ -32492,7 +32772,8 @@ function useAccessManagementController() {
     availableCardContractors,
     vmsgenerateQrCodes,
     addVisitorAccessCard,
-    signQrCode
+    signQrCode,
+    checkoutVisitor
   };
 }
 
@@ -36378,6 +36659,7 @@ var import_node_server_utils175 = require("@7365admin1/node-server-utils");
 // src/repositories/incident-report.repo.ts
 var import_node_server_utils174 = require("@7365admin1/node-server-utils");
 var import_mongodb98 = require("mongodb");
+var incidents_namespace_collection = "incident-reports";
 function useIncidentReportRepo() {
   const db = import_node_server_utils174.useAtlas.getDb();
   if (!db) {
@@ -36404,18 +36686,21 @@ function useIncidentReportRepo() {
       );
     }
   }
-  const namespace_collection = "incident-reports";
-  const collection = db.collection(namespace_collection);
-  const { delNamespace, getCache, setCache } = (0, import_node_server_utils174.useCache)(namespace_collection);
+  const collection = db.collection(incidents_namespace_collection);
+  const { delNamespace, getCache, setCache } = (0, import_node_server_utils174.useCache)(
+    incidents_namespace_collection
+  );
   async function add(value, session) {
     try {
       value = MIncidentReport(value);
       const res = await collection.insertOne(value, { session });
       delNamespace().then(() => {
-        import_node_server_utils174.logger.info(`Cache cleared for namespace: ${namespace_collection}`);
+        import_node_server_utils174.logger.info(
+          `Cache cleared for namespace: ${incidents_namespace_collection}`
+        );
       }).catch((err) => {
         import_node_server_utils174.logger.error(
-          `Failed to clear cache for namespace: ${namespace_collection}`,
+          `Failed to clear cache for namespace: ${incidents_namespace_collection}`,
           err
         );
       });
@@ -36501,7 +36786,7 @@ function useIncidentReportRepo() {
     if (search) {
       cacheOptions.search = search;
     }
-    const cacheKey = (0, import_node_server_utils174.makeCacheKey)(namespace_collection, cacheOptions);
+    const cacheKey = (0, import_node_server_utils174.makeCacheKey)(incidents_namespace_collection, cacheOptions);
     const cachedData = await getCache(cacheKey);
     if (cachedData) {
       import_node_server_utils174.logger.info(`Cache hit for key: ${cacheKey}`);
@@ -36614,7 +36899,7 @@ function useIncidentReportRepo() {
     } catch (error) {
       throw new import_node_server_utils174.BadRequestError("Invalid incident report ID format.");
     }
-    const cacheKey = (0, import_node_server_utils174.makeCacheKey)(namespace_collection, { _id });
+    const cacheKey = (0, import_node_server_utils174.makeCacheKey)(incidents_namespace_collection, { _id });
     const cachedData = await getCache(cacheKey);
     if (cachedData) {
       import_node_server_utils174.logger.info(`Cache hit for key: ${cacheKey}`);
@@ -36688,10 +36973,12 @@ function useIncidentReportRepo() {
         );
       }
       delNamespace().then(() => {
-        import_node_server_utils174.logger.info(`Cache cleared for namespace: ${namespace_collection}`);
+        import_node_server_utils174.logger.info(
+          `Cache cleared for namespace: ${incidents_namespace_collection}`
+        );
       }).catch((err) => {
         import_node_server_utils174.logger.error(
-          `Failed to clear cache for namespace: ${namespace_collection}`,
+          `Failed to clear cache for namespace: ${incidents_namespace_collection}`,
           err
         );
       });
@@ -36717,10 +37004,12 @@ function useIncidentReportRepo() {
         throw new import_node_server_utils174.InternalServerError("Unable to delete occurrence subject.");
       }
       delNamespace().then(() => {
-        import_node_server_utils174.logger.info(`Cache cleared for namespace: ${namespace_collection}`);
+        import_node_server_utils174.logger.info(
+          `Cache cleared for namespace: ${incidents_namespace_collection}`
+        );
       }).catch((err) => {
         import_node_server_utils174.logger.error(
-          `Failed to clear cache for namespace: ${namespace_collection}`,
+          `Failed to clear cache for namespace: ${incidents_namespace_collection}`,
           err
         );
       });
@@ -36748,10 +37037,12 @@ function useIncidentReportRepo() {
         );
       }
       delNamespace().then(() => {
-        import_node_server_utils174.logger.info(`Cache cleared for namespace: ${namespace_collection}`);
+        import_node_server_utils174.logger.info(
+          `Cache cleared for namespace: ${incidents_namespace_collection}`
+        );
       }).catch((err) => {
         import_node_server_utils174.logger.error(
-          `Failed to clear cache for namespace: ${namespace_collection}`,
+          `Failed to clear cache for namespace: ${incidents_namespace_collection}`,
           err
         );
       });
@@ -39133,6 +39424,1634 @@ function useNfcPatrolLogController() {
     getAllBySite
   };
 }
+
+// src/repositories/new-dashboard.repo.ts
+var import_node_server_utils192 = require("@7365admin1/node-server-utils");
+var Period = /* @__PURE__ */ ((Period2) => {
+  Period2["TODAY"] = "today";
+  Period2["THIS_WEEK"] = "thisWeek";
+  Period2["THIS_MONTH"] = "thisMonth";
+  return Period2;
+})(Period || {});
+var securityDashboardCollection = "security-dashboard";
+var PMDashboardCollection = "PM-dashboard";
+var pestDashboardCollection = "pest-dashboard";
+var poolDashboardCollection = "pool-dashboard";
+var mAndEDashboardCollection = "M&E-dashboard";
+var landscapeDashboardCollection = "landscape-dashboard";
+function getPeriodRangeWithPrevious(period) {
+  const now = /* @__PURE__ */ new Date();
+  let currentStart = /* @__PURE__ */ new Date();
+  let currentEnd = /* @__PURE__ */ new Date();
+  let previousStart = /* @__PURE__ */ new Date();
+  let previousEnd = /* @__PURE__ */ new Date();
+  if (period === "today" /* TODAY */) {
+    currentStart.setHours(0, 0, 0, 0);
+    currentEnd.setHours(23, 59, 59, 999);
+    previousStart = new Date(currentStart);
+    previousStart.setDate(previousStart.getDate() - 1);
+    previousEnd = new Date(currentEnd);
+    previousEnd.setDate(previousEnd.getDate() - 1);
+  } else if (period === "thisWeek" /* THIS_WEEK */) {
+    const day = now.getDay();
+    const diffToMonday = day === 0 ? -6 : 1 - day;
+    currentStart = new Date(now);
+    currentStart.setDate(now.getDate() + diffToMonday);
+    currentStart.setHours(0, 0, 0, 0);
+    currentEnd = new Date(currentStart);
+    currentEnd.setDate(currentStart.getDate() + 6);
+    currentEnd.setHours(23, 59, 59, 999);
+    previousStart = new Date(currentStart);
+    previousStart.setDate(previousStart.getDate() - 7);
+    previousEnd = new Date(currentEnd);
+    previousEnd.setDate(previousEnd.getDate() - 7);
+  } else if (period === "thisMonth" /* THIS_MONTH */) {
+    currentStart = new Date(now.getFullYear(), now.getMonth(), 1);
+    currentEnd = new Date(
+      now.getFullYear(),
+      now.getMonth() + 1,
+      0,
+      23,
+      59,
+      59,
+      999
+    );
+    previousStart = new Date(now.getFullYear(), now.getMonth() - 1, 1);
+    previousEnd = new Date(
+      now.getFullYear(),
+      now.getMonth(),
+      0,
+      23,
+      59,
+      59,
+      999
+    );
+  } else {
+    throw new import_node_server_utils192.BadRequestError("Invalid period.");
+  }
+  return {
+    current: {
+      start: currentStart.toISOString(),
+      end: currentEnd.toISOString()
+    },
+    previous: {
+      start: previousStart.toISOString(),
+      end: previousEnd.toISOString()
+    }
+  };
+}
+function calculatePercentage(current, previous) {
+  if (previous === 0) {
+    return current === 0 ? 0 : 100;
+  }
+  return Number(((current - previous) / previous * 100).toFixed(2));
+}
+function useNewDashboardRepo() {
+  const db = import_node_server_utils192.useAtlas.getDb();
+  if (!db) {
+    throw new import_node_server_utils192.InternalServerError("Unable to connect to server.");
+  }
+  const { delNamespace, getCache, setCache } = (0, import_node_server_utils192.useCache)(
+    securityDashboardCollection
+  );
+  async function getMetric(collectionString, siteId, period) {
+    const site = (0, import_node_server_utils192.toObjectId)(siteId);
+    const range = getPeriodRangeWithPrevious(period);
+    const collection = db.collection(collectionString);
+    const current = await collection.countDocuments({
+      site,
+      createdAt: {
+        $gte: range.current.start,
+        $lte: range.current.end
+      }
+    });
+    const previous = await collection.countDocuments({
+      site,
+      createdAt: {
+        $gte: range.previous.start,
+        $lte: range.previous.end
+      }
+    });
+    return {
+      count: current,
+      percentage: calculatePercentage(current, previous)
+    };
+  }
+  async function getSecurityDashboard({
+    siteId = "",
+    feedback = "today" /* TODAY */,
+    workOrder = "today" /* TODAY */,
+    vehicle = "today" /* TODAY */,
+    building = "today" /* TODAY */,
+    visitor = "today" /* TODAY */,
+    incident = "today" /* TODAY */,
+    guest = "today" /* TODAY */
+  }) {
+    const cacheOptions = {
+      siteId,
+      feedback,
+      workOrder,
+      vehicle,
+      building,
+      visitor,
+      incident
+    };
+    const cacheKey = (0, import_node_server_utils192.makeCacheKey)(securityDashboardCollection, cacheOptions);
+    const cachedData = await getCache(cacheKey);
+    if (cachedData) {
+      import_node_server_utils192.logger.info(`Cache hit for key: ${cacheKey}`);
+      return cachedData;
+    }
+    const feedbacks = await getMetric(
+      feedbacks_namespace_collection,
+      siteId,
+      feedback
+    );
+    const workOrders = await getMetric(
+      work_orders_namespace_collection,
+      siteId,
+      workOrder
+    );
+    const vehicles = await getMetric(
+      vehicles_namespace_collection,
+      siteId,
+      vehicle
+    );
+    const buildings = await getMetric(
+      buildings_namespace_collection,
+      siteId,
+      building
+    );
+    const visitors = await getMetric(
+      visitors_namespace_collection,
+      siteId,
+      visitor
+    );
+    const incidents = await getMetric(
+      incidents_namespace_collection,
+      siteId,
+      incident
+    );
+    const guests = await getMetric(guests_namespace_collection, siteId, guest);
+    const data = {
+      feedbacks,
+      workOrders,
+      vehicles,
+      buildings,
+      visitors,
+      incidents,
+      guests
+    };
+    setCache(cacheKey, data, 15 * 60).then(() => {
+      import_node_server_utils192.logger.info(`Cache set for key: ${cacheKey}`);
+    }).catch((err) => {
+      import_node_server_utils192.logger.error(`Failed to set cache for key: ${cacheKey}`, err);
+    });
+    return data;
+  }
+  async function getPropertyManagementDashboard({
+    siteId = "",
+    feedback = "today" /* TODAY */,
+    workOrder = "today" /* TODAY */,
+    sitePeople = "today" /* TODAY */,
+    facilityBooking = "today" /* TODAY */,
+    bulletinBoard = "today" /* TODAY */,
+    event = "today" /* TODAY */,
+    vehicle = "today" /* TODAY */,
+    building = "today" /* TODAY */,
+    visitor = "today" /* TODAY */,
+    incident = "today" /* TODAY */
+  }) {
+    const cacheOptions = {
+      siteId,
+      feedback,
+      workOrder,
+      sitePeople,
+      facilityBooking,
+      bulletinBoard,
+      event,
+      vehicle,
+      building,
+      visitor,
+      incident
+    };
+    const cacheKey = (0, import_node_server_utils192.makeCacheKey)(PMDashboardCollection, cacheOptions);
+    const cachedData = await getCache(cacheKey);
+    if (cachedData) {
+      import_node_server_utils192.logger.info(`Cache hit for key: ${cacheKey}`);
+      return cachedData;
+    }
+    const feedbacks = await getMetric(
+      feedbacks_namespace_collection,
+      siteId,
+      feedback
+    );
+    const workOrders = await getMetric(
+      work_orders_namespace_collection,
+      siteId,
+      workOrder
+    );
+    const vehicles = await getMetric(
+      vehicles_namespace_collection,
+      siteId,
+      vehicle
+    );
+    const buildings = await getMetric(
+      buildings_namespace_collection,
+      siteId,
+      building
+    );
+    const visitors = await getMetric(
+      visitors_namespace_collection,
+      siteId,
+      visitor
+    );
+    const incidents = await getMetric(
+      incidents_namespace_collection,
+      siteId,
+      incident
+    );
+    const _sitePeople = await getMetric(
+      site_people_namespace_collection,
+      siteId,
+      sitePeople
+    );
+    const bulletinBoards = await getMetric(
+      bulletin_boards_namespace_collection,
+      siteId,
+      bulletinBoard
+    );
+    const events = await getMetric(events_namespace_collection, siteId, event);
+    const facilityBookings = await getMetric(
+      facility_bookings_namespace_collection,
+      siteId,
+      facilityBooking
+    );
+    const data = {
+      feedbacks,
+      workOrders,
+      vehicles,
+      buildings,
+      visitors,
+      incidents,
+      sitePeople: _sitePeople,
+      bulletinBoards,
+      events,
+      facilityBookings
+    };
+    setCache(cacheKey, data, 15 * 60).then(() => {
+      import_node_server_utils192.logger.info(`Cache set for key: ${cacheKey}`);
+    }).catch((err) => {
+      import_node_server_utils192.logger.error(`Failed to set cache for key: ${cacheKey}`, err);
+    });
+    return data;
+  }
+  async function getPestManagementDashboard({
+    siteId = "",
+    feedback = "today" /* TODAY */,
+    workOrder = "today" /* TODAY */
+  }) {
+    const cacheOptions = {
+      siteId,
+      feedback,
+      workOrder
+    };
+    const cacheKey = (0, import_node_server_utils192.makeCacheKey)(pestDashboardCollection, cacheOptions);
+    const cachedData = await getCache(cacheKey);
+    if (cachedData) {
+      import_node_server_utils192.logger.info(`Cache hit for key: ${cacheKey}`);
+      return cachedData;
+    }
+    const feedbacks = await getMetric(
+      feedbacks_namespace_collection,
+      siteId,
+      feedback
+    );
+    const workOrders = await getMetric(
+      work_orders_namespace_collection,
+      siteId,
+      workOrder
+    );
+    const data = {
+      feedbacks,
+      workOrders
+    };
+    setCache(cacheKey, data, 15 * 60).then(() => {
+      import_node_server_utils192.logger.info(`Cache set for key: ${cacheKey}`);
+    }).catch((err) => {
+      import_node_server_utils192.logger.error(`Failed to set cache for key: ${cacheKey}`, err);
+    });
+    return data;
+  }
+  async function getPoolManagementDashboard({
+    siteId = "",
+    feedback = "today" /* TODAY */,
+    workOrder = "today" /* TODAY */
+  }) {
+    const cacheOptions = {
+      siteId,
+      feedback,
+      workOrder
+    };
+    const cacheKey = (0, import_node_server_utils192.makeCacheKey)(poolDashboardCollection, cacheOptions);
+    const cachedData = await getCache(cacheKey);
+    if (cachedData) {
+      import_node_server_utils192.logger.info(`Cache hit for key: ${cacheKey}`);
+      return cachedData;
+    }
+    const feedbacks = await getMetric(
+      feedbacks_namespace_collection,
+      siteId,
+      feedback
+    );
+    const workOrders = await getMetric(
+      work_orders_namespace_collection,
+      siteId,
+      workOrder
+    );
+    const data = {
+      feedbacks,
+      workOrders
+    };
+    setCache(cacheKey, data, 15 * 60).then(() => {
+      import_node_server_utils192.logger.info(`Cache set for key: ${cacheKey}`);
+    }).catch((err) => {
+      import_node_server_utils192.logger.error(`Failed to set cache for key: ${cacheKey}`, err);
+    });
+    return data;
+  }
+  async function getMAndEManagementDashboard({
+    siteId = "",
+    feedback = "today" /* TODAY */,
+    workOrder = "today" /* TODAY */
+  }) {
+    const cacheOptions = {
+      siteId,
+      feedback,
+      workOrder
+    };
+    const cacheKey = (0, import_node_server_utils192.makeCacheKey)(mAndEDashboardCollection, cacheOptions);
+    const cachedData = await getCache(cacheKey);
+    if (cachedData) {
+      import_node_server_utils192.logger.info(`Cache hit for key: ${cacheKey}`);
+      return cachedData;
+    }
+    const feedbacks = await getMetric(
+      feedbacks_namespace_collection,
+      siteId,
+      feedback
+    );
+    const workOrders = await getMetric(
+      work_orders_namespace_collection,
+      siteId,
+      workOrder
+    );
+    const data = {
+      feedbacks,
+      workOrders
+    };
+    setCache(cacheKey, data, 15 * 60).then(() => {
+      import_node_server_utils192.logger.info(`Cache set for key: ${cacheKey}`);
+    }).catch((err) => {
+      import_node_server_utils192.logger.error(`Failed to set cache for key: ${cacheKey}`, err);
+    });
+    return data;
+  }
+  async function getLandscapeDashboard({
+    siteId = "",
+    feedback = "today" /* TODAY */,
+    workOrder = "today" /* TODAY */
+  }) {
+    const cacheOptions = {
+      siteId,
+      feedback,
+      workOrder
+    };
+    const cacheKey = (0, import_node_server_utils192.makeCacheKey)(landscapeDashboardCollection, cacheOptions);
+    const cachedData = await getCache(cacheKey);
+    if (cachedData) {
+      import_node_server_utils192.logger.info(`Cache hit for key: ${cacheKey}`);
+      return cachedData;
+    }
+    const feedbacks = await getMetric(
+      feedbacks_namespace_collection,
+      siteId,
+      feedback
+    );
+    const workOrders = await getMetric(
+      work_orders_namespace_collection,
+      siteId,
+      workOrder
+    );
+    const data = {
+      feedbacks,
+      workOrders
+    };
+    setCache(cacheKey, data, 15 * 60).then(() => {
+      import_node_server_utils192.logger.info(`Cache set for key: ${cacheKey}`);
+    }).catch((err) => {
+      import_node_server_utils192.logger.error(`Failed to set cache for key: ${cacheKey}`, err);
+    });
+    return data;
+  }
+  return {
+    getSecurityDashboard,
+    getPropertyManagementDashboard,
+    getPestManagementDashboard,
+    getPoolManagementDashboard,
+    getMAndEManagementDashboard,
+    getLandscapeDashboard
+  };
+}
+
+// src/controllers/new-dashboard.controller.ts
+var import_joi110 = __toESM(require("joi"));
+var import_node_server_utils193 = require("@7365admin1/node-server-utils");
+function useNewDashboardController() {
+  const {
+    getSecurityDashboard: _getSecurityDashboard,
+    getPropertyManagementDashboard: _getPropertyManagementDashboard,
+    getPestManagementDashboard: _getPestManagementDashboard,
+    getPoolManagementDashboard: _getPoolManagementDashboard,
+    getMAndEManagementDashboard: _getMAndEManagementDashboard,
+    getLandscapeDashboard: _getLandscapeDashboard
+  } = useNewDashboardRepo();
+  const periodField = import_joi110.default.string().valid(...Object.values(Period)).default("today" /* TODAY */);
+  async function getSecurityDashboard(req, res, next) {
+    try {
+      const schema2 = import_joi110.default.object({
+        site: import_joi110.default.string().hex().length(24).required(),
+        feedbackPeriod: periodField,
+        workOrderPeriod: periodField,
+        vehiclePeriod: periodField,
+        buildingPeriod: periodField,
+        visitorPeriod: periodField,
+        incidentPeriod: periodField,
+        guestPeriod: periodField
+      });
+      const { error, value } = schema2.validate({
+        site: req.params.site,
+        ...req.query
+      });
+      if (error) {
+        const messages = error.details.map((d) => d.message).join(", ");
+        import_node_server_utils193.logger.log({ level: "error", message: messages });
+        next(new import_node_server_utils193.BadRequestError(messages));
+        return;
+      }
+      const {
+        site,
+        feedbackPeriod,
+        workOrderPeriod,
+        vehiclePeriod,
+        buildingPeriod,
+        visitorPeriod,
+        incidentPeriod,
+        guestPeriod
+      } = value;
+      const data = await _getSecurityDashboard({
+        siteId: site,
+        feedback: feedbackPeriod,
+        workOrder: workOrderPeriod,
+        vehicle: vehiclePeriod,
+        building: buildingPeriod,
+        visitor: visitorPeriod,
+        incident: incidentPeriod,
+        guest: guestPeriod
+      });
+      res.status(200).json(data);
+      return;
+    } catch (error) {
+      import_node_server_utils193.logger.log({ level: "error", message: error.message });
+      next(error);
+      return;
+    }
+  }
+  async function getPropertyManagementDashboard(req, res, next) {
+    try {
+      const schema2 = import_joi110.default.object({
+        site: import_joi110.default.string().hex().length(24).required(),
+        feedbackPeriod: periodField,
+        workOrderPeriod: periodField,
+        vehiclePeriod: periodField,
+        buildingPeriod: periodField,
+        visitorPeriod: periodField,
+        incidentPeriod: periodField,
+        sitePeoplePeriod: periodField,
+        bulletinBoardPeriod: periodField,
+        eventPeriod: periodField,
+        facilityBookingPeriod: periodField
+      });
+      const { error, value } = schema2.validate({
+        site: req.params.site,
+        ...req.query
+      });
+      if (error) {
+        const messages = error.details.map((d) => d.message).join(", ");
+        import_node_server_utils193.logger.log({ level: "error", message: messages });
+        next(new import_node_server_utils193.BadRequestError(messages));
+        return;
+      }
+      const {
+        site,
+        feedbackPeriod,
+        workOrderPeriod,
+        vehiclePeriod,
+        buildingPeriod,
+        visitorPeriod,
+        incidentPeriod,
+        sitePeoplePeriod,
+        bulletinBoardPeriod,
+        eventPeriod,
+        facilityBookingPeriod
+      } = value;
+      const data = await _getPropertyManagementDashboard({
+        siteId: site,
+        feedback: feedbackPeriod,
+        workOrder: workOrderPeriod,
+        vehicle: vehiclePeriod,
+        building: buildingPeriod,
+        visitor: visitorPeriod,
+        incident: incidentPeriod,
+        sitePeople: sitePeoplePeriod,
+        bulletinBoard: bulletinBoardPeriod,
+        event: eventPeriod,
+        facilityBooking: facilityBookingPeriod
+      });
+      res.status(200).json(data);
+      return;
+    } catch (error) {
+      import_node_server_utils193.logger.log({ level: "error", message: error.message });
+      next(error);
+      return;
+    }
+  }
+  async function getPestManagementDashboard(req, res, next) {
+    try {
+      const schema2 = import_joi110.default.object({
+        site: import_joi110.default.string().hex().length(24).required(),
+        feedbackPeriod: periodField,
+        workOrderPeriod: periodField
+      });
+      const { error, value } = schema2.validate({
+        site: req.params.site,
+        ...req.query
+      });
+      if (error) {
+        const messages = error.details.map((d) => d.message).join(", ");
+        import_node_server_utils193.logger.log({ level: "error", message: messages });
+        next(new import_node_server_utils193.BadRequestError(messages));
+        return;
+      }
+      const { site, feedbackPeriod, workOrderPeriod } = value;
+      const data = await _getPestManagementDashboard({
+        siteId: site,
+        feedback: feedbackPeriod,
+        workOrder: workOrderPeriod
+      });
+      res.status(200).json(data);
+      return;
+    } catch (error) {
+      import_node_server_utils193.logger.log({ level: "error", message: error.message });
+      next(error);
+      return;
+    }
+  }
+  async function getPoolManagementDashboard(req, res, next) {
+    try {
+      const schema2 = import_joi110.default.object({
+        site: import_joi110.default.string().hex().length(24).required(),
+        feedbackPeriod: periodField,
+        workOrderPeriod: periodField
+      });
+      const { error, value } = schema2.validate({
+        site: req.params.site,
+        ...req.query
+      });
+      if (error) {
+        const messages = error.details.map((d) => d.message).join(", ");
+        import_node_server_utils193.logger.log({ level: "error", message: messages });
+        next(new import_node_server_utils193.BadRequestError(messages));
+        return;
+      }
+      const { site, feedbackPeriod, workOrderPeriod } = value;
+      const data = await _getPestManagementDashboard({
+        siteId: site,
+        feedback: feedbackPeriod,
+        workOrder: workOrderPeriod
+      });
+      res.status(200).json(data);
+      return;
+    } catch (error) {
+      import_node_server_utils193.logger.log({ level: "error", message: error.message });
+      next(error);
+      return;
+    }
+  }
+  async function getMAndEManagementDashboard(req, res, next) {
+    try {
+      const schema2 = import_joi110.default.object({
+        site: import_joi110.default.string().hex().length(24).required(),
+        feedbackPeriod: periodField,
+        workOrderPeriod: periodField
+      });
+      const { error, value } = schema2.validate({
+        site: req.params.site,
+        ...req.query
+      });
+      if (error) {
+        const messages = error.details.map((d) => d.message).join(", ");
+        import_node_server_utils193.logger.log({ level: "error", message: messages });
+        next(new import_node_server_utils193.BadRequestError(messages));
+        return;
+      }
+      const { site, feedbackPeriod, workOrderPeriod } = value;
+      const data = await _getMAndEManagementDashboard({
+        siteId: site,
+        feedback: feedbackPeriod,
+        workOrder: workOrderPeriod
+      });
+      res.status(200).json(data);
+      return;
+    } catch (error) {
+      import_node_server_utils193.logger.log({ level: "error", message: error.message });
+      next(error);
+      return;
+    }
+  }
+  async function getLandscapeDashboard(req, res, next) {
+    try {
+      const schema2 = import_joi110.default.object({
+        site: import_joi110.default.string().hex().length(24).required(),
+        feedbackPeriod: periodField,
+        workOrderPeriod: periodField
+      });
+      const { error, value } = schema2.validate({
+        site: req.params.site,
+        ...req.query
+      });
+      if (error) {
+        const messages = error.details.map((d) => d.message).join(", ");
+        import_node_server_utils193.logger.log({ level: "error", message: messages });
+        next(new import_node_server_utils193.BadRequestError(messages));
+        return;
+      }
+      const { site, feedbackPeriod, workOrderPeriod } = value;
+      const data = await _getLandscapeDashboard({
+        siteId: site,
+        feedback: feedbackPeriod,
+        workOrder: workOrderPeriod
+      });
+      res.status(200).json(data);
+      return;
+    } catch (error) {
+      import_node_server_utils193.logger.log({ level: "error", message: error.message });
+      next(error);
+      return;
+    }
+  }
+  return {
+    getSecurityDashboard,
+    getPropertyManagementDashboard,
+    getPestManagementDashboard,
+    getPoolManagementDashboard,
+    getMAndEManagementDashboard,
+    getLandscapeDashboard
+  };
+}
+
+// src/models/manpower-monitoring.model.ts
+var import_joi111 = __toESM(require("joi"));
+var import_mongodb107 = require("mongodb");
+var shiftSchema = import_joi111.default.object({
+  name: import_joi111.default.string().required(),
+  checkIn: import_joi111.default.string().optional().allow("", null),
+  checkOut: import_joi111.default.string().optional().allow("", null),
+  lateCheckInAlert: import_joi111.default.string().optional().allow("", null),
+  alertFrequencyMins: import_joi111.default.number().optional().allow("", null),
+  earlyOutAlert: import_joi111.default.boolean().optional()
+});
+var manpowerMonitoringSchema = import_joi111.default.object({
+  siteId: import_joi111.default.string().hex().required(),
+  siteName: import_joi111.default.string().required(),
+  shiftType: import_joi111.default.string().optional().allow("", null),
+  enabled: import_joi111.default.boolean().required(),
+  shifts: import_joi111.default.object({
+    "2-shifts": import_joi111.default.array().items(shiftSchema).optional(),
+    "3-shifts": import_joi111.default.array().items(shiftSchema).optional()
+  }).optional(),
+  createdBy: import_joi111.default.string().hex().required(),
+  createdByName: import_joi111.default.string().optional().allow("", null),
+  emails: import_joi111.default.array().items(import_joi111.default.string().email()).optional(),
+  serviceProviderId: import_joi111.default.string().hex().optional()
+});
+var MManpowerMonitoring = class {
+  constructor(data) {
+    this._id = new import_mongodb107.ObjectId();
+    this.serviceProviderId = data.serviceProviderId || "";
+    this.siteId = data.siteId || "";
+    this.siteName = data.siteName;
+    this.shiftType = data.shiftType;
+    this.enabled = data.enabled;
+    this.shifts = data.shifts;
+    this.createdBy = data.createdBy || "";
+    this.createdByName = data.createdByName || "";
+    this.createdAt = /* @__PURE__ */ new Date();
+    this.updatedAt = data.updatedAt || "";
+    this.emails = data.emails || [];
+  }
+};
+
+// src/repositories/manpower-monitoring.repo.ts
+var import_node_server_utils194 = require("@7365admin1/node-server-utils");
+
+// src/utils/hrmlabs-attendance.util.ts
+var import_axios2 = __toESM(require("axios"));
+async function hrmLabsAuthentication({
+  authUrl,
+  username,
+  password,
+  domain
+}) {
+  const res = await import_axios2.default.post(
+    authUrl,
+    {
+      grant_type: "password",
+      username,
+      password,
+      domain,
+      showPassword: false
+    },
+    {
+      headers: { "Content-Type": "application/json" }
+    }
+  );
+  if (res.data?.success && res.data.data?.token) {
+    return res.data.data.token;
+  }
+  throw new Error(
+    "HRMLabs Authentication failed. Please check your credentials."
+  );
+}
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+async function fetchSites({ siteUrl, token }) {
+  const maxRetries = 3;
+  let attempt = 0;
+  let lastError;
+  do {
+    try {
+      attempt++;
+      const res = await import_axios2.default.get(siteUrl, {
+        headers: { Authorization: `Bearer ${token}` },
+        timeout: 15e3
+      });
+      if (res.status !== 200) {
+        throw new Error(`Unexpected status: ${res.status}`);
+      }
+      return res.data.data.locations[0] || [];
+    } catch (err) {
+      const error = err;
+      lastError = error;
+      const status = error.response?.status;
+      if (status && status >= 400 && status < 500 && status !== 429) {
+        throw error;
+      }
+      if (attempt < maxRetries) {
+        const delay = 1e3 * attempt;
+        await sleep(delay);
+      }
+    }
+  } while (attempt < maxRetries);
+  throw lastError;
+}
+var hrmlabs_attendance_util_default = {
+  hrmLabsAuthentication,
+  fetchSites
+};
+
+// src/repositories/manpower-monitoring.repo.ts
+var import_mongodb108 = require("mongodb");
+var { hrmLabsAuthentication: hrmLabsAuthentication2, fetchSites: fetchSites2 } = hrmlabs_attendance_util_default;
+function useManpowerMonitoringRepo() {
+  const db = import_node_server_utils194.useAtlas.getDb();
+  if (!db) {
+    throw new Error("Unable to connect to server.");
+  }
+  const namespace_collection = "manpower-monitoring";
+  const collection = db.collection(namespace_collection);
+  const serviceProviderCollection = db.collection("site.service-providers");
+  async function createManpowerMonitoringSettings(value, session) {
+    try {
+      value = new MManpowerMonitoring(value);
+      if (value.createdBy)
+        value.createdBy = new import_mongodb108.ObjectId(value.createdBy);
+      if (value.siteId)
+        value.siteId = new import_mongodb108.ObjectId(value.siteId);
+      if (value.serviceProviderId)
+        value.serviceProviderId = new import_mongodb108.ObjectId(value.serviceProviderId);
+      const result = await collection.insertOne(value, { session });
+      return result;
+    } catch (error) {
+      throw new Error(error.message || error || "Server Internal Error");
+    }
+  }
+  async function getAllManpowerSettings({
+    page = 1,
+    limit = 10,
+    search
+  }) {
+    try {
+      page = page ? page - 1 : 0;
+      limit = limit || 10;
+      const searchQuery = {};
+      if (search) {
+        searchQuery.siteName = { $regex: search, $options: "i" };
+      }
+      const result = await collection.aggregate([
+        { $match: searchQuery },
+        {
+          $facet: {
+            totalCount: [{ $count: "count" }],
+            items: [
+              { $sort: { _id: -1 } },
+              { $skip: page * limit },
+              { $limit: limit }
+            ]
+          }
+        }
+      ]).toArray();
+      const total = result[0].totalCount[0]?.count || 0;
+      const items = result[0].items;
+      return (0, import_node_server_utils194.paginate)(items, page, limit, total);
+    } catch (error) {
+      throw new Error(error.message || "Server Internal Error");
+    }
+  }
+  async function getManpowerSettingsBySiteId(_id, serviceProviderId) {
+    try {
+      _id = new import_mongodb108.ObjectId(_id);
+      serviceProviderId = new import_mongodb108.ObjectId(serviceProviderId);
+    } catch (error) {
+      throw new Error("Invalid Site ID format.");
+    }
+    try {
+      const data = await collection.findOne({
+        siteId: _id,
+        serviceProviderId
+      });
+      return data;
+    } catch (error) {
+      throw error;
+    }
+  }
+  async function updateManpowerMonitoringSettings(_id, value) {
+    try {
+      _id = new import_mongodb108.ObjectId(_id);
+    } catch (error) {
+      throw new import_node_server_utils194.BadRequestError("Invalid ID format.");
+    }
+    try {
+      const updateValue = {
+        ...value,
+        updatedAt: /* @__PURE__ */ new Date()
+      };
+      const res = await collection.updateOne({ _id }, { $set: updateValue });
+      if (res.modifiedCount === 0) {
+        throw new Error("Unable to update manpower monitoring settings.");
+      }
+      return res.modifiedCount;
+    } catch (error) {
+      throw error;
+    }
+  }
+  async function multipleManpowerMonitoringSettings(value) {
+    try {
+      const results = {
+        updated: 0,
+        inserted: 0
+      };
+      for (let item of value) {
+        item = new MManpowerMonitoring(item);
+        const data = await collection.findOne({
+          siteId: new import_mongodb108.ObjectId(item.siteId)
+        });
+        if (data) {
+          let updateValue;
+          if (item.shiftType == "2-shifts") {
+            updateValue = {
+              shiftType: item.shiftType,
+              "shifts.2-shifts": item.shifts["2-shifts"]
+            };
+          }
+          if (item.shiftType == "3-shifts") {
+            updateValue = {
+              shiftType: item.shiftType,
+              "shifts.3-shifts": item.shifts["3-shifts"]
+            };
+          }
+          const res = await collection.updateOne(
+            { _id: data._id },
+            { $set: updateValue }
+          );
+          if (res.modifiedCount > 0) {
+            results.updated++;
+          }
+        } else {
+          if (item.createdBy)
+            item.createdBy = new import_mongodb108.ObjectId(item.createdBy);
+          if (item.siteId)
+            item.siteId = new import_mongodb108.ObjectId(item.siteId);
+          if (item.serviceProviderId)
+            item.serviceProviderId = new import_mongodb108.ObjectId(item.serviceProviderId);
+          const result = await collection.insertOne(item);
+          if (result.insertedId) {
+            results.inserted++;
+          }
+        }
+      }
+      return {
+        success: true,
+        message: `Processed ${value.length} items.`,
+        ...results
+      };
+    } catch (error) {
+      throw new Error(error.message || error || "Server Internal Error");
+    }
+  }
+  async function getAllSites(serviceProviderId) {
+    const username = process.env.HRMLABS_USERNAME;
+    const domain = process.env.HRMLABS_DOMAIN;
+    const password = process.env.HRMLABS_PASSWORD;
+    const authUrl = process.env.HRMLABS_AUTH_URL;
+    const siteUrl = process.env.HRMLABS_SITE_URL;
+    try {
+      const serviceProvider = await serviceProviderCollection.findOne({
+        _id: new import_mongodb108.ObjectId(serviceProviderId)
+      });
+      if (!serviceProvider) {
+        throw new Error("Service Provider not found.");
+      }
+      const hasDomain = serviceProvider.name.toLowerCase().includes(domain?.toLowerCase());
+      if (!hasDomain) {
+        return [];
+      }
+      const token = await hrmLabsAuthentication2({
+        authUrl,
+        username,
+        password,
+        domain
+      });
+      const sites = await fetchSites2({ siteUrl, token });
+      if (!sites) {
+        throw new Error("Failed to fetch sites from HRMLabs.");
+      }
+      return sites.children;
+    } catch (error) {
+      throw new Error(error.message || "Server Internal Error");
+    }
+  }
+  return {
+    createManpowerMonitoringSettings,
+    getAllManpowerSettings,
+    getManpowerSettingsBySiteId,
+    updateManpowerMonitoringSettings,
+    multipleManpowerMonitoringSettings,
+    getAllSites
+  };
+}
+
+// src/services/manpower-monitoring.service.ts
+var import_node_server_utils195 = require("@7365admin1/node-server-utils");
+var import_moment_timezone = __toESM(require("moment-timezone"));
+function useManpowerMonitoringSrvc() {
+  const {
+    createManpowerMonitoringSettings: _createManpowerMonitoringSettings
+  } = useManpowerMonitoringRepo();
+  async function createManpowerMonitoringSettings(payload) {
+    console.log("Im here now at service");
+    const session = import_node_server_utils195.useAtlas.getClient()?.startSession();
+    if (!session) {
+      throw new import_node_server_utils195.BadRequestError("Database session not available.");
+    }
+    await session.startTransaction();
+    const morningCheckInTime = payload?.shifts?.[payload.shiftType][0]?.checkIn;
+    const afternoonCheckInTime = payload.shiftType == "3-shifts" ? payload?.shifts?.[payload.shiftType][1]?.checkIn : null;
+    const nightCheckInTime = payload.shiftType == "3-shifts" ? payload?.shifts?.[payload.shiftType][2]?.checkIn : payload?.shifts?.[payload.shiftType][1]?.checkIn;
+    const morningAlertFrequencyMins = payload?.shifts?.[payload.shiftType][0]?.alertFrequencyMins;
+    const afternoonAlertFrequencyMins = payload.shiftType == "3-shifts" ? payload?.shifts?.[payload.shiftType][1]?.alertFrequencyMins : null;
+    const nightAlertFrequencyMins = payload.shiftType == "3-shifts" ? payload?.shifts?.[payload.shiftType][2]?.alertFrequencyMins : payload?.shifts?.[payload.shiftType][1]?.alertFrequencyMins;
+    const morningAlertTime = import_moment_timezone.default.tz(morningCheckInTime, "HH:mm", "Asia/Singapore").add(morningAlertFrequencyMins, "minutes").format("HH:mm");
+    const afternoonAlertTime = afternoonCheckInTime ? import_moment_timezone.default.tz(afternoonCheckInTime, "HH:mm", "Asia/Singapore").add(afternoonAlertFrequencyMins, "minutes").format("HH:mm") : "";
+    const nightAlertTime = import_moment_timezone.default.tz(nightCheckInTime, "HH:mm", "Asia/Singapore").add(nightAlertFrequencyMins, "minutes").format("HH:mm");
+    const nowSGT = (0, import_moment_timezone.default)().tz("Asia/Singapore");
+    console.log("im done preparing the payload");
+    try {
+      const remarksPayload = {
+        siteId: payload.siteId,
+        siteName: payload.siteName,
+        serviceProviderId: payload.serviceProviderId,
+        remarks: [
+          {
+            name: "Morning Shift",
+            remark: {
+              isAcknowledged: false,
+              status: "",
+              acknowledgementRemarks: "",
+              acknowledgedAt: ""
+            }
+          },
+          {
+            name: "Afternoon Shift",
+            remark: {
+              isAcknowledged: true,
+              status: "",
+              acknowledgementRemarks: "",
+              acknowledgedAt: ""
+            }
+          },
+          {
+            name: "Night Shift",
+            remark: {
+              isAcknowledged: false,
+              status: "",
+              acknowledgementRemarks: "",
+              acknowledgedAt: ""
+            }
+          }
+        ],
+        createdBy: "",
+        createdByName: "",
+        morningAlertTime,
+        afternoonAlertTime,
+        nightAlertTime,
+        createdAt: /* @__PURE__ */ new Date(),
+        createdAtSGT: nowSGT.format("DD-MM-YYYY"),
+        updatedAt: "",
+        status: "active"
+      };
+      console.log("im here at remarks payload");
+      const result = await _createManpowerMonitoringSettings(payload, session);
+      await session.commitTransaction();
+      return result;
+    } catch (error) {
+      await session.abortTransaction();
+      import_node_server_utils195.logger.error(error.message || error);
+      console.error("Error creating monitoring settings:", error);
+      throw new Error(error?.message || "Internal Server Error!");
+    } finally {
+      session.endSession();
+    }
+  }
+  return {
+    createManpowerMonitoringSettings
+  };
+}
+
+// src/controllers/manpower-monitoring.controller.ts
+var import_node_server_utils196 = require("@7365admin1/node-server-utils");
+var import_joi112 = __toESM(require("joi"));
+function useManpowerMonitoringCtrl() {
+  const {
+    getAllManpowerSettings: _getAllManpowerSettings,
+    getManpowerSettingsBySiteId: _getManpowerSettingsBySiteId,
+    updateManpowerMonitoringSettings: _updateManpowerMonitoringSettings,
+    multipleManpowerMonitoringSettings: _multipleManpowerMonitoringSettings,
+    getAllSites: _getAllSites
+  } = useManpowerMonitoringRepo();
+  const {
+    createManpowerMonitoringSettings: _createManpowerMonitoringSettings
+  } = useManpowerMonitoringSrvc();
+  async function createManpowerMonitoringSettings(req, res, next) {
+    try {
+      const payload = { ...req.body };
+      const { error } = manpowerMonitoringSchema.validate(payload);
+      if (error) {
+        next(new import_node_server_utils196.BadRequestError(error.message));
+        return;
+      }
+      const result = await _createManpowerMonitoringSettings(payload);
+      return res.json(result);
+    } catch (error) {
+      import_node_server_utils196.logger.log({ level: "error", message: error.message });
+      next(error);
+      return;
+    }
+  }
+  async function getAllManpowerSettings(req, res, next) {
+    try {
+      const { page, search, limit } = req.query;
+      const schema2 = import_joi112.default.object({
+        page: import_joi112.default.number().optional().allow("", null),
+        limit: import_joi112.default.number().optional().allow("", null),
+        search: import_joi112.default.string().optional().allow("", null)
+      });
+      const { error } = schema2.validate({ page, search, limit });
+      if (error) {
+        next(new import_node_server_utils196.BadRequestError(error.message));
+        return;
+      }
+      const result = await _getAllManpowerSettings({
+        page: Number(page),
+        limit: Number(limit),
+        search
+      });
+      return res.json(result);
+    } catch (error) {
+      import_node_server_utils196.logger.log({ level: "error", message: error.message });
+      next(error);
+      return;
+    }
+  }
+  async function getManpowerSettingsBySiteId(req, res, next) {
+    try {
+      const _id = req.params.id;
+      const serviceProviderId = req.params.serviceProviderId;
+      const schema2 = import_joi112.default.object({
+        _id: import_joi112.default.string().hex().required(),
+        serviceProviderId: import_joi112.default.string().hex().required()
+      });
+      const { error } = schema2.validate({ _id, serviceProviderId });
+      if (error) {
+        next(new import_node_server_utils196.BadRequestError(error.message));
+        return;
+      }
+      const result = await _getManpowerSettingsBySiteId(_id, serviceProviderId);
+      return res.json(result);
+    } catch (error) {
+      import_node_server_utils196.logger.log({ level: "error", message: error.message });
+      next(error);
+      return;
+    }
+  }
+  async function updateManpowerMonitoringSettings(req, res, next) {
+    try {
+      const validation = import_joi112.default.object({
+        _id: import_joi112.default.string().hex().required(),
+        shiftType: import_joi112.default.string().optional().allow("", null),
+        enabled: import_joi112.default.boolean().required(),
+        shifts: import_joi112.default.object({
+          "2-shifts": import_joi112.default.array().items(shiftSchema).optional(),
+          "3-shifts": import_joi112.default.array().items(shiftSchema).optional()
+        }).optional(),
+        emails: import_joi112.default.array().items(import_joi112.default.string().email()).optional()
+      });
+      const _id = req.params.id;
+      const payload = { ...req.body };
+      console.log("_id", _id);
+      const { error } = validation.validate({ _id, ...payload });
+      if (error) {
+        next(new import_node_server_utils196.BadRequestError(error.message));
+        return;
+      }
+      const result = await _updateManpowerMonitoringSettings(_id, payload);
+      return res.json(result);
+    } catch (error) {
+      import_node_server_utils196.logger.log({ level: "error", message: error.message });
+      next(error);
+      return;
+    }
+  }
+  async function multipleManpowerMonitoringSettings(req, res, next) {
+    try {
+      const validation = import_joi112.default.array().items(manpowerMonitoringSchema);
+      const payload = req.body;
+      const { error } = validation.validate(payload);
+      if (error) {
+        next(new import_node_server_utils196.BadRequestError(error.message));
+        return;
+      }
+      const result = await _multipleManpowerMonitoringSettings(payload);
+      return res.json(result);
+    } catch (error) {
+      import_node_server_utils196.logger.log({ level: "error", message: error.message });
+      next(error);
+      return;
+    }
+  }
+  async function getAllSites(req, res, next) {
+    try {
+      const serviceProviderId = req.query.serviceProviderId;
+      const validation = import_joi112.default.object({
+        serviceProviderId: import_joi112.default.string().hex().required()
+      });
+      const { error } = validation.validate({ serviceProviderId });
+      if (error) {
+        next(new import_node_server_utils196.BadRequestError(error.message));
+        return;
+      }
+      const result = await _getAllSites(serviceProviderId);
+      return res.json(result);
+    } catch (error) {
+      import_node_server_utils196.logger.log({ level: "error", message: error.message });
+      next(error);
+      return;
+    }
+  }
+  return {
+    createManpowerMonitoringSettings,
+    getAllManpowerSettings,
+    getManpowerSettingsBySiteId,
+    updateManpowerMonitoringSettings,
+    multipleManpowerMonitoringSettings,
+    getAllSites
+  };
+}
+
+// src/models/manpower-designations.model.ts
+var import_joi113 = __toESM(require("joi"));
+var import_mongodb109 = require("mongodb");
+var designationsSchema = import_joi113.default.object({
+  title: import_joi113.default.string().required(),
+  shifts: import_joi113.default.object({
+    morningShift: import_joi113.default.number().required(),
+    afternoonShift: import_joi113.default.number().optional(),
+    nightShift: import_joi113.default.number().required()
+  }).required()
+});
+var manpowerDesignationsSchema = import_joi113.default.object({
+  siteId: import_joi113.default.string().hex().required(),
+  siteName: import_joi113.default.string().required(),
+  serviceProviderId: import_joi113.default.string().hex().optional(),
+  designations: import_joi113.default.array().items(designationsSchema).required(),
+  createdBy: import_joi113.default.string().hex().required(),
+  createdByName: import_joi113.default.string().optional().allow("", null)
+});
+var MManpowerDesignations = class {
+  constructor(data) {
+    this._id = new import_mongodb109.ObjectId();
+    this.siteId = data.siteId || "";
+    this.siteName = data.siteName || "";
+    this.serviceProviderId = data.serviceProviderId || "";
+    this.designations = data.designations || [];
+    this.createdBy = data.createdBy || "";
+    this.createdByName = data.createdByName || "";
+    this.createdAt = /* @__PURE__ */ new Date();
+    this.updatedAt = data.updatedAt || "";
+  }
+};
+
+// src/repositories/manpower-designations.repo.ts
+var import_node_server_utils197 = require("@7365admin1/node-server-utils");
+var import_mongodb110 = require("mongodb");
+function useManpowerDesignationRepo() {
+  const db = import_node_server_utils197.useAtlas.getDb();
+  if (!db) {
+    throw new Error("Unable to connect to server.");
+  }
+  const namespace_collection = "manpower-designations";
+  const collection = db.collection(namespace_collection);
+  async function createManpowerDesignations(value) {
+    try {
+      value = new MManpowerDesignations(value);
+      if (value.createdBy)
+        value.createdBy = new import_mongodb110.ObjectId(value.createdBy);
+      if (value.siteId)
+        value.siteId = new import_mongodb110.ObjectId(value.siteId);
+      if (value.serviceProviderId)
+        value.serviceProviderId = new import_mongodb110.ObjectId(value.serviceProviderId);
+      const result = await collection.insertOne(value);
+      return result;
+    } catch (error) {
+      throw new Error(error.message || error || "Server Internal Error");
+    }
+  }
+  async function getManpowerDesignationsBySiteId(_id, serviceProviderId) {
+    try {
+      _id = new import_mongodb110.ObjectId(_id);
+      serviceProviderId = new import_mongodb110.ObjectId(serviceProviderId);
+    } catch (error) {
+      throw new Error("Invalid Site ID format.");
+    }
+    try {
+      const data = await collection.findOne({
+        siteId: _id,
+        serviceProviderId
+      });
+      return data;
+    } catch (error) {
+      throw error;
+    }
+  }
+  async function updateManpowerDesignations(_id, value) {
+    try {
+      _id = new import_mongodb110.ObjectId(_id);
+    } catch (error) {
+      throw new Error("Invalid ID format.");
+    }
+    try {
+      const updateValue = {
+        ...value,
+        updatedAt: /* @__PURE__ */ new Date()
+      };
+      const res = await collection.updateOne({ _id }, { $set: updateValue });
+      if (res.modifiedCount === 0) {
+        throw new Error("Unable to update manpower designations.");
+      }
+      return res.modifiedCount;
+    } catch (error) {
+      throw error;
+    }
+  }
+  return {
+    createManpowerDesignations,
+    getManpowerDesignationsBySiteId,
+    updateManpowerDesignations
+  };
+}
+
+// src/controllers/manpower-designations.controller.ts
+var import_node_server_utils198 = require("@7365admin1/node-server-utils");
+var import_joi114 = __toESM(require("joi"));
+function useManpowerDesignationCtrl() {
+  const {
+    createManpowerDesignations: _createManpowerDesignations,
+    getManpowerDesignationsBySiteId: _getManpowerDesignationsBySiteId,
+    updateManpowerDesignations: _updateManpowerDesignations
+  } = useManpowerDesignationRepo();
+  async function createManpowerDesignations(req, res, next) {
+    try {
+      const payload = { ...req.body };
+      const { error } = manpowerDesignationsSchema.validate(payload);
+      if (error) {
+        next(new import_node_server_utils198.BadRequestError(error.message));
+        return;
+      }
+      const result = await _createManpowerDesignations(payload);
+      return res.json(result);
+    } catch (error) {
+      import_node_server_utils198.logger.log({ level: "error", message: error.message });
+      next(error);
+      return;
+    }
+  }
+  async function getManpowerSettingsBySiteId(req, res, next) {
+    try {
+      const { id, serviceProviderId } = req.params;
+      const schema2 = import_joi114.default.object({
+        id: import_joi114.default.string().hex().required(),
+        serviceProviderId: import_joi114.default.string().hex().required()
+      });
+      const { error } = schema2.validate({ id, serviceProviderId });
+      if (error) {
+        next(new import_node_server_utils198.BadRequestError(error.message));
+        return;
+      }
+      const result = await _getManpowerDesignationsBySiteId(
+        id,
+        serviceProviderId
+      );
+      return res.json(result);
+    } catch (error) {
+      import_node_server_utils198.logger.log({ level: "error", message: error.message });
+      next(error);
+      return;
+    }
+  }
+  async function updateManpowerDesignations(req, res, next) {
+    try {
+      const validation = import_joi114.default.object({
+        _id: import_joi114.default.string().hex().required(),
+        designations: import_joi114.default.array().items(designationsSchema).required()
+      });
+      const _id = req.params.id;
+      const payload = { ...req.body };
+      const { error } = validation.validate({ _id, ...payload });
+      if (error) {
+        next(new import_node_server_utils198.BadRequestError(error.message));
+        return;
+      }
+      const result = await _updateManpowerDesignations(_id, payload);
+      return res.json(result);
+    } catch (error) {
+      import_node_server_utils198.logger.log({ level: "error", message: error.message });
+      next(error);
+      return;
+    }
+  }
+  return {
+    createManpowerDesignations,
+    getManpowerSettingsBySiteId,
+    updateManpowerDesignations
+  };
+}
+
+// src/models/overnight-parking.model.ts
+var import_joi115 = __toESM(require("joi"));
+var import_mongodb111 = require("mongodb");
+var dayScheduleSchema = import_joi115.default.object({
+  isEnabled: import_joi115.default.boolean().required(),
+  startTime: import_joi115.default.string().pattern(/^([01]\d|2[0-3]):([0-5]\d)$/).required().messages({
+    "string.pattern.base": "startTime must be in HH:mm format"
+  }),
+  endTime: import_joi115.default.string().pattern(/^([01]\d|2[0-3]):([0-5]\d)$/).required().messages({
+    "string.pattern.base": "endTime must be in HH:mm format"
+  })
+}).required();
+var schemaOvernightParkingApprovalHours = import_joi115.default.object({
+  _id: import_joi115.default.string().hex().length(24).optional(),
+  site: import_joi115.default.string().hex().length(24).required(),
+  monday: dayScheduleSchema,
+  tuesday: dayScheduleSchema,
+  wednesday: dayScheduleSchema,
+  thursday: dayScheduleSchema,
+  friday: dayScheduleSchema,
+  saturday: dayScheduleSchema,
+  sunday: dayScheduleSchema,
+  createdAt: import_joi115.default.date().optional(),
+  updatedAt: import_joi115.default.date().optional(),
+  deletedAt: import_joi115.default.date().optional().allow(null)
+});
+function MOvernightParkingApprovalHours(value) {
+  const { error } = schemaOvernightParkingApprovalHours.validate(value);
+  if (error) {
+    throw new Error(error.details[0].message);
+  }
+  if (value.site && typeof value.site === "string") {
+    try {
+      value.site = new import_mongodb111.ObjectId(value.site);
+    } catch {
+      throw new Error("Invalid site ID.");
+    }
+  }
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  return {
+    ...value,
+    createdAt: value.createdAt ?? now,
+    updatedAt: value.updatedAt ?? now
+  };
+}
+
+// src/repositories/overnight-parking.repo.ts
+var import_node_server_utils199 = require("@7365admin1/node-server-utils");
+var overnight_parking_namespace_collection = "site.overnight-parking";
+function useOvernightParkingRepo() {
+  const db = import_node_server_utils199.useAtlas.getDb();
+  if (!db) {
+    throw new import_node_server_utils199.InternalServerError("Unable to connect to server.");
+  }
+  const collection = db.collection(overnight_parking_namespace_collection);
+  const { delNamespace, setCache, getCache } = (0, import_node_server_utils199.useCache)(
+    overnight_parking_namespace_collection
+  );
+  async function createIndexes() {
+    try {
+      const existingIndexes = await collection.indexes();
+      const existingNames = new Set(existingIndexes.map((i) => i.name));
+      const indexesToEnsure = [
+        {
+          key: { site: 1 },
+          name: "site-index"
+        },
+        {
+          key: { status: 1 },
+          name: "status-index"
+        }
+      ];
+      const indexesToCreate = indexesToEnsure.filter(
+        (index) => index.name && !existingNames.has(index.name)
+      );
+      if (indexesToCreate.length > 0) {
+        await collection.createIndexes(indexesToCreate);
+      }
+    } catch (error) {
+      throw new import_node_server_utils199.InternalServerError("Failed to create collection indexes.");
+    }
+  }
+  async function upsert(value, session) {
+    try {
+      value = MOvernightParkingApprovalHours(value);
+      const now = (/* @__PURE__ */ new Date()).toISOString();
+      const res = await collection.updateOne(
+        { site: value.site },
+        {
+          $set: {
+            monday: value.monday,
+            tuesday: value.tuesday,
+            wednesday: value.wednesday,
+            thursday: value.thursday,
+            friday: value.friday,
+            saturday: value.saturday,
+            sunday: value.sunday,
+            updatedAt: now
+          },
+          $setOnInsert: {
+            site: value.site,
+            createdAt: value.createdAt ?? now
+          }
+        },
+        { upsert: true, session }
+      );
+      delNamespace().then(() => {
+        import_node_server_utils199.logger.info(
+          `Cache cleared for namespace: ${overnight_parking_namespace_collection}`
+        );
+      }).catch((err) => {
+        import_node_server_utils199.logger.error(
+          `Failed to clear cache for namespace: ${overnight_parking_namespace_collection}`,
+          err
+        );
+      });
+      return res;
+    } catch (error) {
+      throw error;
+    }
+  }
+  async function getSiteOvernightParking(site) {
+    const siteId = (0, import_node_server_utils199.toObjectId)(site);
+    const cacheKey = (0, import_node_server_utils199.makeCacheKey)(overnight_parking_namespace_collection, {
+      site
+    });
+    const cachedData = await getCache(cacheKey);
+    if (cachedData) {
+      import_node_server_utils199.logger.info(`Cache hit for key: ${cacheKey}`);
+      return cachedData;
+    }
+    try {
+      const data = await collection.findOne({
+        site: siteId,
+        deletedAt: null
+      });
+      setCache(cacheKey, data, 15 * 60).then(() => {
+        import_node_server_utils199.logger.info(`Cache set for key: ${cacheKey}`);
+      }).catch((err) => {
+        import_node_server_utils199.logger.error(`Failed to set cache for key: ${cacheKey}`, err);
+      });
+      return data;
+    } catch (error) {
+      throw error;
+    }
+  }
+  return {
+    upsert,
+    getSiteOvernightParking,
+    createIndexes
+  };
+}
+
+// src/controllers/overnight-parking.controller.ts
+var import_joi116 = __toESM(require("joi"));
+var import_node_server_utils200 = require("@7365admin1/node-server-utils");
+function useOvernightParkingController() {
+  const { upsert: _upsert, getSiteOvernightParking: _getSiteOvernightParking } = useOvernightParkingRepo();
+  async function upsert(req, res, next) {
+    const site = req.params.site;
+    req.body.site = site;
+    try {
+      const { error, value } = schemaOvernightParkingApprovalHours.validate(
+        req.body,
+        {
+          abortEarly: false
+        }
+      );
+      if (error) {
+        const messages = error.details.map((d) => d.message).join(", ");
+        import_node_server_utils200.logger.log({ level: "error", message: messages });
+        next(new import_node_server_utils200.BadRequestError(messages));
+        return;
+      }
+      const data = await _upsert(value);
+      res.status(201).json(data);
+      return;
+    } catch (error) {
+      import_node_server_utils200.logger.log({ level: "error", message: error.message });
+      next(error);
+      return;
+    }
+  }
+  async function getSiteOvernightParking(req, res, next) {
+    const schema2 = import_joi116.default.object({
+      site: import_joi116.default.string().hex().length(24).required()
+    });
+    try {
+      const { error, value } = schema2.validate(
+        { site: req.params.site },
+        {
+          abortEarly: false
+        }
+      );
+      if (error) {
+        const messages = error.details.map((d) => d.message).join(", ");
+        import_node_server_utils200.logger.log({ level: "error", message: messages });
+        next(new import_node_server_utils200.BadRequestError(messages));
+        return;
+      }
+      const { site } = value;
+      const data = await _getSiteOvernightParking(site);
+      res.status(201).json(data);
+      return;
+    } catch (error) {
+      import_node_server_utils200.logger.log({ level: "error", message: error.message });
+      next(error);
+      return;
+    }
+  }
+  return {
+    upsert,
+    getSiteOvernightParking
+  };
+}
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   ANPRMode,
@@ -39170,6 +41089,8 @@ function useNfcPatrolLogController() {
   MFile,
   MGuestManagement,
   MIncidentReport,
+  MManpowerDesignations,
+  MManpowerMonitoring,
   MMember,
   MNfcPatrolLog,
   MNfcPatrolRoute,
@@ -39181,6 +41102,7 @@ function useNfcPatrolLogController() {
   MOccurrenceSubject,
   MOnlineForm,
   MOrg,
+  MOvernightParkingApprovalHours,
   MPatrolLog,
   MPatrolQuestion,
   MPatrolRoute,
@@ -39206,6 +41128,8 @@ function useNfcPatrolLogController() {
   MWorkOrder,
   OrgNature,
   PERSON_TYPES,
+  PMDashboardCollection,
+  Period,
   PersonTypes,
   SiteCategories,
   SiteStatus,
@@ -39223,14 +41147,30 @@ function useNfcPatrolLogController() {
   allowedNatures,
   attendanceSchema,
   attendanceSettingsSchema,
+  buildings_namespace_collection,
+  bulletin_boards_namespace_collection,
+  calculatePercentage,
   chatSchema,
   customerSchema,
+  designationsSchema,
+  events_namespace_collection,
+  facility_bookings_namespace_collection,
   feedbackSchema,
+  feedbacks_namespace_collection,
   formatDahuaDate,
+  getPeriodRangeWithPrevious,
+  guests_namespace_collection,
   incidentReportLog,
+  incidents_namespace_collection,
+  landscapeDashboardCollection,
+  mAndEDashboardCollection,
+  manpowerDesignationsSchema,
+  manpowerMonitoringSchema,
   nfcPatrolSettingsSchema,
   nfcPatrolSettingsSchemaUpdate,
   orgSchema,
+  pestDashboardCollection,
+  poolDashboardCollection,
   promoCodeSchema,
   robotSchema,
   schema,
@@ -39257,6 +41197,7 @@ function useNfcPatrolLogController() {
   schemaOccurrenceEntry,
   schemaOccurrenceSubject,
   schemaOnlineForm,
+  schemaOvernightParkingApprovalHours,
   schemaPatrolLog,
   schemaPatrolQuestion,
   schemaPatrolRoute,
@@ -39298,7 +41239,10 @@ function useNfcPatrolLogController() {
   schemaVisitorTransaction,
   schemeCamera,
   schemeLogCamera,
+  securityDashboardCollection,
+  shiftSchema,
   siteSchema,
+  site_people_namespace_collection,
   tokenSchema,
   updateSiteSchema,
   useAccessManagementController,
@@ -39357,8 +41301,15 @@ function useNfcPatrolLogController() {
   useInvoiceController,
   useInvoiceModel,
   useInvoiceRepo,
+  useManpowerDesignationCtrl,
+  useManpowerDesignationRepo,
+  useManpowerMonitoringCtrl,
+  useManpowerMonitoringRepo,
+  useManpowerMonitoringSrvc,
   useMemberController,
   useMemberRepo,
+  useNewDashboardController,
+  useNewDashboardRepo,
   useNfcPatrolLogController,
   useNfcPatrolLogRepo,
   useNfcPatrolLogService,
@@ -39384,6 +41335,8 @@ function useNfcPatrolLogController() {
   useOnlineFormRepo,
   useOrgController,
   useOrgRepo,
+  useOvernightParkingController,
+  useOvernightParkingRepo,
   usePatrolLogController,
   usePatrolLogRepo,
   usePatrolQuestionController,
@@ -39449,6 +41402,9 @@ function useNfcPatrolLogController() {
   useWorkOrderService,
   userSchema,
   vehicleSchema,
-  workOrderSchema
+  vehicles_namespace_collection,
+  visitors_namespace_collection,
+  workOrderSchema,
+  work_orders_namespace_collection
 });
 //# sourceMappingURL=index.js.map