@7365admin1/core 2.22.0 → 2.23.0

package/dist/index.js

@@ -69,6 +69,7 @@ __export(src_exports, {
   MManpowerDesignations: () => MManpowerDesignations,
   MManpowerMonitoring: () => MManpowerMonitoring,
   MManpowerRemarks: () => MManpowerRemarks,
+  MManpowerSites: () => MManpowerSites,
   MMember: () => MMember,
   MNfcPatrolLog: () => MNfcPatrolLog,
   MNfcPatrolRoute: () => MNfcPatrolRoute,
@@ -134,6 +135,7 @@ __export(src_exports, {
   bulletin_boards_namespace_collection: () => bulletin_boards_namespace_collection,
   calculatePercentage: () => calculatePercentage,
   chatSchema: () => chatSchema,
+  createManpowerRemarksDaily: () => createManpowerRemarksDaily,
   customerSchema: () => customerSchema,
   designationsSchema: () => designationsSchema,
   events_namespace_collection: () => events_namespace_collection,
@@ -148,10 +150,13 @@ __export(src_exports, {
   landscapeDashboardCollection: () => landscapeDashboardCollection,
   mAndEDashboardCollection: () => mAndEDashboardCollection,
   manpowerDesignationsSchema: () => manpowerDesignationsSchema,
+  manpowerEvents: () => manpowerEvents,
   manpowerMonitoringSchema: () => manpowerMonitoringSchema,
   manpowerRemarksSchema: () => manpowerRemarksSchema,
+  manpowerSitesSchema: () => manpowerSitesSchema,
   nfcPatrolSettingsSchema: () => nfcPatrolSettingsSchema,
   nfcPatrolSettingsSchemaUpdate: () => nfcPatrolSettingsSchemaUpdate,
+  occurrence_book_namespace_collection: () => occurrence_book_namespace_collection,
   orgSchema: () => orgSchema,
   overnight_parking_requests_namespace_collection: () => overnight_parking_requests_namespace_collection,
   pestDashboardCollection: () => pestDashboardCollection,
@@ -232,6 +237,8 @@ __export(src_exports, {
   siteSchema: () => siteSchema,
   site_people_namespace_collection: () => site_people_namespace_collection,
   tokenSchema: () => tokenSchema,
+  updateRemarksStatusEod: () => updateRemarksStatusEod,
+  updateRemarksisAcknowledged: () => updateRemarksisAcknowledged,
   updateSiteSchema: () => updateSiteSchema,
   useAccessManagementController: () => useAccessManagementController,
   useAddressRepo: () => useAddressRepo,
@@ -298,6 +305,9 @@ __export(src_exports, {
   useManpowerMonitoringSrvc: () => useManpowerMonitoringSrvc,
   useManpowerRemarkCtrl: () => useManpowerRemarkCtrl,
   useManpowerRemarksRepo: () => useManpowerRemarksRepo,
+  useManpowerSitesCtrl: () => useManpowerSitesCtrl,
+  useManpowerSitesRepo: () => useManpowerSitesRepo,
+  useManpowerSitesSrvc: () => useManpowerSitesSrvc,
   useMemberController: () => useMemberController,
   useMemberRepo: () => useMemberRepo,
   useNewDashboardController: () => useNewDashboardController,
@@ -12990,7 +13000,8 @@ var schemaPerson = import_joi35.default.object({
   companyName: import_joi35.default.array().items(import_joi35.default.string()).optional(),
   plates: import_joi35.default.array().items(schemaPlate).optional().allow(null),
   isOwner: import_joi35.default.boolean().required(),
-  files: import_joi35.default.array().items(schemaFiles).optional().allow(null)
+  files: import_joi35.default.array().items(schemaFiles).optional().allow(null),
+  password: import_joi35.default.string().optional().allow(null, "")
 });
 var schemaUpdatePerson = import_joi35.default.object({
   _id: import_joi35.default.string().hex().required(),
@@ -13009,7 +13020,8 @@ var schemaUpdatePerson = import_joi35.default.object({
   companyName: import_joi35.default.array().items(import_joi35.default.string()).optional().allow(null, ""),
   plates: import_joi35.default.array().items(schemaFiles).optional().allow(null, ""),
   isOwner: import_joi35.default.boolean().optional().allow(null, ""),
-  files: import_joi35.default.array().items(schemaFiles).optional().allow(null)
+  files: import_joi35.default.array().items(schemaFiles).optional().allow(null),
+  password: import_joi35.default.string().optional().allow(null, "")
 });
 function MPerson(value) {
   const { error } = schemaPerson.validate(value);
@@ -13060,6 +13072,7 @@ function MPerson(value) {
     end: value.end,
     type: value.type,
     email: value.email,
+    password: value.password ?? "",
     status: value.status ?? "active",
     nric: value.nric,
     remarks: value.remarks,
@@ -13609,6 +13622,8 @@ var VehicleSort = /* @__PURE__ */ ((VehicleSort2) => {
   VehicleSort2["CREATED_AT"] = "createdAt";
   VehicleSort2["ID"] = "_id";
   VehicleSort2["NAME"] = "name";
+  VehicleSort2["START"] = "start";
+  VehicleSort2["END"] = "end";
   return VehicleSort2;
 })(VehicleSort || {});
 var OrgNature = /* @__PURE__ */ ((OrgNature2) => {
@@ -13761,6 +13776,7 @@ var import_mongodb41 = require("mongodb");
 var import_joi38 = __toESM(require("joi"));
 var vehicles_namespace_collection = "vehicles";
 function useVehicleRepo() {
+  vehicles_namespace_collection;
   const db = import_node_server_utils69.useAtlas.getDb();
   if (!db) {
     throw new import_node_server_utils69.InternalServerError("Unable to connect to server.");
@@ -18238,11 +18254,13 @@ function useVehicleController() {
     getAllVehiclesByUnitId: _getAllVehiclesByUnitId
   } = useVehicleRepo();
   async function add(req, res, next) {
-    const payload = req.body;
-    const { error, value } = vehicleSchema.validate(payload);
+    const { error, value } = vehicleSchema.validate(req.body, {
+      abortEarly: false
+    });
     if (error) {
-      import_node_server_utils85.logger.log({ level: "error", message: error.message });
-      next(new import_node_server_utils85.BadRequestError(error.message));
+      const messages = error.details.map((d) => d.message).join(", ");
+      import_node_server_utils85.logger.log({ level: "error", message: messages });
+      next(new import_node_server_utils85.BadRequestError(messages));
       return;
     }
     try {
@@ -18258,40 +18276,29 @@ function useVehicleController() {
     }
   }
   async function getVehicles(req, res, next) {
-    const allowedFields = ["start", "end"];
-    const allowedOrder = ["asc", "desc"];
-    const validation = import_joi46.default.object({
+    const schema2 = import_joi46.default.object({
       search: import_joi46.default.string().optional().allow("", null),
-      page: import_joi46.default.number().integer().min(1).allow("", null).default(1),
-      limit: import_joi46.default.number().integer().min(1).max(100).allow("", null).default(10),
-      sort: import_joi46.default.string().pattern(/^([a-zA-Z0-9_]+)(,[a-zA-Z0-9_]+)*$/).optional().allow("", ...allowedFields),
-      order: import_joi46.default.string().pattern(/^(asc|desc)(,(asc|desc))*$/).optional().allow("", ...allowedOrder),
+      page: import_joi46.default.number().integer().min(1).optional().default(1),
+      limit: import_joi46.default.number().integer().min(1).max(100).optional().default(10),
+      sort: import_joi46.default.string().optional().valid(...Object.values(VehicleSort)),
+      order: import_joi46.default.string().optional().valid(...Object.values(SortOrder)),
       type: import_joi46.default.string().optional().valid(...Object.values(VehicleType)).allow(null, ""),
       category: import_joi46.default.string().optional().valid(...Object.values(VehicleCategory)).allow(null, ""),
       status: import_joi46.default.string().optional().valid(...Object.values(VehicleStatus)).allow(null, "")
     });
-    const query = { ...req.query };
-    const { error } = validation.validate(query);
+    const { error, value } = schema2.validate(req.query, {
+      abortEarly: false
+    });
     if (error) {
-      import_node_server_utils85.logger.log({ level: "error", message: error.message });
-      next(new import_node_server_utils85.BadRequestError(error.message));
+      const messages = error.details.map((d) => d.message).join(", ");
+      import_node_server_utils85.logger.log({ level: "error", message: messages });
+      next(new import_node_server_utils85.BadRequestError(messages));
       return;
     }
-    const search = req.query.search ?? "";
-    const page = parseInt(req.query.page ?? "1");
-    const limit = parseInt(req.query.limit ?? "10");
-    const type = req.query.type ?? "";
-    const category = req.query.category ?? "";
-    const status = req.query.status ?? "";
-    const sortObj = {};
-    const sortFields = String(req.query.sort).split(",");
-    const sortOrders = String(req.query.order).split(",");
-    sortFields.forEach((field, index) => {
-      if (allowedFields.includes(field)) {
-        const order = sortOrders[index] === "asc" ? 1 : -1;
-        sortObj[field] = order;
-      }
-    });
+    const { search, page, limit, type, category, status, sort, order } = value;
+    const sortObj = {
+      [sort ? sort : "_id" /* ID */]: order === "asc" /* ASC */ ? 1 : -1
+    };
     try {
       const data = await _getVehicles({
         search,
@@ -18311,14 +18318,20 @@ function useVehicleController() {
     }
   }
   async function getSeasonPassTypes(req, res, next) {
-    const validation = import_joi46.default.string().hex().required();
-    const site = req.params.site;
-    const { error } = validation.validate(site);
+    const schema2 = import_joi46.default.object({
+      site: import_joi46.default.string().hex().length(24).required()
+    });
+    const { error, value } = schema2.validate(
+      { site: req.params.site },
+      { abortEarly: false }
+    );
     if (error) {
-      import_node_server_utils85.logger.log({ level: "error", message: error.message });
-      next(new import_node_server_utils85.BadRequestError(error.message));
+      const messages = error.details.map((d) => d.message).join(", ");
+      import_node_server_utils85.logger.log({ level: "error", message: messages });
+      next(new import_node_server_utils85.BadRequestError(messages));
       return;
     }
+    const { site } = value;
     try {
       const data = await _getSeasonPassTypes(site);
       res.json(data);
@@ -18330,14 +18343,20 @@ function useVehicleController() {
     }
   }
   async function getVehicleById(req, res, next) {
-    const validation = import_joi46.default.string().hex().required();
-    const _id = req.params.id;
-    const { error } = validation.validate(_id);
+    const schema2 = import_joi46.default.object({
+      _id: import_joi46.default.string().hex().length(24).required()
+    });
+    const { error, value } = schema2.validate(
+      { _id: req.params.id },
+      { abortEarly: false }
+    );
     if (error) {
-      import_node_server_utils85.logger.log({ level: "error", message: error.message });
-      next(new import_node_server_utils85.BadRequestError(error.message));
+      const messages = error.details.map((d) => d.message).join(", ");
+      import_node_server_utils85.logger.log({ level: "error", message: messages });
+      next(new import_node_server_utils85.BadRequestError(messages));
       return;
     }
+    const { _id } = value;
     try {
       const site = await _getVehicleById(_id);
       res.json(site);
@@ -18350,7 +18369,7 @@ function useVehicleController() {
   }
   async function updateVehicleById(req, res, next) {
     try {
-      const validation = import_joi46.default.object({
+      const schema2 = import_joi46.default.object({
         _id: import_joi46.default.string().hex().length(24).required(),
         site: import_joi46.default.string().hex().length(24).required(),
         name: import_joi46.default.string().optional().allow("", null),
@@ -18365,13 +18384,17 @@ function useVehicleController() {
         recNo: import_joi46.default.string().optional().allow(null, ""),
         type: import_joi46.default.string().optional().valid(...Object.values(VehicleType)).allow(null, "")
       });
-      const { error, value } = validation.validate({
-        _id: req.params.id,
-        ...req.body
-      });
+      const { error, value } = schema2.validate(
+        {
+          _id: req.params.id,
+          ...req.body
+        },
+        { abortEarly: false }
+      );
       if (error) {
-        import_node_server_utils85.logger.log({ level: "error", message: error.message });
-        next(new import_node_server_utils85.BadRequestError(error.message));
+        const messages = error.details.map((d) => d.message).join(", ");
+        import_node_server_utils85.logger.log({ level: "error", message: messages });
+        next(new import_node_server_utils85.BadRequestError(messages));
         return;
       }
       const { _id, ...rest } = value;
@@ -18385,21 +18408,24 @@ function useVehicleController() {
     }
   }
   async function deleteVehicle(req, res, next) {
-    const _id = req.params.id;
     const deleteVehicleSchema = import_joi46.default.object({
       _id: import_joi46.default.string().hex().length(24).required(),
       recno: import_joi46.default.string().required(),
       site: import_joi46.default.string().hex().length(24).required(),
-      type: import_joi46.default.string().valid("whitelist", "blocklist").required(),
+      type: import_joi46.default.string().valid(...Object.values(VehicleType)).required(),
       bypass: import_joi46.default.boolean().optional().default(true)
     });
-    const { error, value } = deleteVehicleSchema.validate({ _id, ...req.body });
+    const { error, value } = deleteVehicleSchema.validate({
+      _id: req.params.id,
+      ...req.body
+    });
     if (error) {
-      import_node_server_utils85.logger.log({ level: "error", message: error.message });
-      next(new import_node_server_utils85.BadRequestError(error.message));
+      const messages = error.details.map((d) => d.message).join(", ");
+      import_node_server_utils85.logger.log({ level: "error", message: messages });
+      next(new import_node_server_utils85.BadRequestError(messages));
       return;
     }
-    const { recno, site, type, bypass } = value;
+    const { recno, site, type, bypass, _id } = value;
     try {
       const data = await _deleteVehicle(_id, recno, site, type, bypass);
       res.json({
@@ -21173,9 +21199,19 @@ function usePersonService() {
     updateById: _updateById
   } = usePersonRepo();
   const { addPlateNumber: _addPlateNumber } = useDahuaService();
+  const {
+    createUser: addUser,
+    getUserById,
+    getUserByEmail,
+    updatePassword,
+    updateUserFieldById: _updateUserFieldById
+  } = useUserRepo();
+  const { add: addMember } = useMemberRepo();
   const { getById: _getUnitById, updateById: updateUnitById } = useBuildingUnitRepo();
   const { getAllCameraWithPassword: _getAllSiteCameras } = useSiteCameraRepo();
   const { updateStatusById } = useFileRepo();
+  const { getById: getOrgById } = useOrgRepo();
+  const { getSiteById } = useSiteRepo();
   async function add(value) {
     const session = import_node_server_utils104.useAtlas.getClient()?.startSession();
     if (!session) {
@@ -21196,6 +21232,49 @@ function usePersonService() {
           }
         }
       }
+      const isValidType = ["resident" /* RESIDENT */, "tenant" /* TENANT */].includes(
+        value?.type
+      );
+      if (value.email && value.password && value.name && isValidType) {
+        const _user = await getUserByEmail(value.email);
+        if (_user) {
+          throw new import_node_server_utils104.BadRequestError(`User already exists: ${value.email}.`);
+        }
+        const hashedPassword = await (0, import_node_server_utils104.hashPassword)(value.password);
+        const user = {
+          email: value.email,
+          password: hashedPassword,
+          name: value.name,
+          defaultOrg: value.org?.toString() || ""
+        };
+        const userId = await addUser(user, session);
+        let org = null;
+        if (userId) {
+          if (value?.org) {
+            org = await getOrgById(value.org);
+            if (!org) {
+              value.org = "";
+            }
+          }
+          let site;
+          if (value.site) {
+            site = await getSiteById(value.site);
+          }
+          await addMember(
+            {
+              org: value.org?.toString() || "",
+              orgName: org?.name || "",
+              user: userId.toString(),
+              name: value.name,
+              role: "",
+              type: "resident",
+              siteId: value.site?.toString() || "",
+              siteName: site?.name || ""
+            },
+            session
+          );
+        }
+      }
       await _add(value, session);
       await session.commitTransaction();
       return "People added successfully.";
@@ -25566,14 +25645,17 @@ function useSiteFacilityBookingController() {
     }
   }
   async function deleteSiteFacilityBookingById(req, res, next) {
-    const validation = import_joi72.default.string().hex().required();
-    const _id = req.params.id;
-    const { error } = validation.validate(_id);
+    const schema2 = import_joi72.default.object({
+      _id: import_joi72.default.string().hex().length(24).required()
+    });
+    const { error, value } = schema2.validate({ _id: req.params.id });
     if (error) {
-      import_node_server_utils128.logger.log({ level: "error", message: error.message });
-      next(new import_node_server_utils128.BadRequestError(error.message));
+      const messages = error.details.map((d) => d.message).join(", ");
+      import_node_server_utils128.logger.log({ level: "error", message: messages });
+      next(new import_node_server_utils128.BadRequestError(messages));
       return;
     }
+    const { _id } = value;
     try {
       await _deleteSiteFacilityBookingById(_id);
       res.status(200).json({ message: "Successfully deleted site facility booking." });
@@ -29582,6 +29664,7 @@ var import_mongodb84 = require("mongodb");
 var import_fs2 = __toESM(require("fs"));
 var import_path = __toESM(require("path"));
 var import_axios = __toESM(require("axios"));
+var import_xml2js = require("xml2js");
 var import_crypto = __toESM(require("crypto"));
 var ALGORITHM = "aes-256-gcm";
 var SECRET_KEY = import_crypto.default.createSecretKey(
@@ -29682,9 +29765,39 @@ var formatEntryPassDate = (date) => {
   const day = String(newDate.getDate()).padStart(2, "0");
   return `${year}${month}${day}`;
 };
+async function removeAccessGroup({ cardNo, staffNo, url }) {
+  try {
+    const commands = readTemplate("delete-qr-card", {
+      staffNo,
+      // dateOfJoin: formatEntryPassDate(cardDetails.startDate),
+      // accessLevel: cardDetails.accessLevel,
+      cardNo
+      // pin: cardDetails.pin,
+      // startDate: formatEntryPassDate(cardDetails.startDate),
+      // endDate: formatEntryPassDate(cardDetails.endDate),
+      // cardType: 0,
+      // isActivated: cardDetails.isActivated ? 1 : 0,
+      // isAntiPassBack: cardDetails.isAntiPassBack ? 1 : 0,
+      // isLiftCard: cardDetails.isLiftCard ? 1 : 0,
+      // isLiftActivate: cardDetails.isLiftCard ? 1 : 0,
+      // liftAccessLevel: cardDetails.liftAccessLevel || 1,
+      // liftAccessStartDate: formatEntryPassDate(cardDetails.liftAccessStartDate) || "19770510",
+      // liftAccessEndDate: formatEntryPassDate(cardDetails.liftAccessEndDate) || "19770510",
+    });
+    const response = await sendCommand(commands, url);
+    const result = await (0, import_xml2js.parseStringPromise)(response, { explicitArray: false });
+    console.log(result.RESULT.$.STCODE);
+    console.log(commands);
+    if (result && result.RESULT.$.STCODE !== "0") {
+      throw new Error("Command failed, server error.");
+    }
+  } catch (error) {
+    console.log(error);
+  }
+}
 
 // src/repositories/access-management.repo.ts
-var import_xml2js = require("xml2js");
+var import_xml2js2 = require("xml2js");
 
 // src/utils/rsa-encryption.ts
 var crypto2 = __toESM(require("crypto"));
@@ -30693,7 +30806,7 @@ function UseAccessManagementRepo() {
         return readTemplate(`${item.accessLevel !== null ? "add-card" : "add-card-lift"}`, { ...command });
       }).flat();
       const response = await sendCommand(commands.join("").toString(), params.acm_url);
-      const result = await (0, import_xml2js.parseStringPromise)(response, { explicitArray: false });
+      const result = await (0, import_xml2js2.parseStringPromise)(response, { explicitArray: false });
       if (result && result.RESULT.$.STCODE !== "0") {
         throw new Error("Command failed, server error.");
       }
@@ -31554,7 +31667,7 @@ function UseAccessManagementRepo() {
           return readTemplate(`${item.accessLevel !== null ? "add-card" : "add-card-lift"}`, { ...command });
         }).flat();
         const response = await sendCommand(commands.join("").toString(), acm_url);
-        serverResult = await (0, import_xml2js.parseStringPromise)(response, { explicitArray: false });
+        serverResult = await (0, import_xml2js2.parseStringPromise)(response, { explicitArray: false });
         if (result && serverResult.RESULT.$.STCODE !== "0") {
           throw new Error("Command failed, server error.");
         }
@@ -31650,7 +31763,7 @@ function UseAccessManagementRepo() {
 var import_joi85 = __toESM(require("joi"));
 
 // src/services/access-management.service.ts
-var import_xml2js2 = require("xml2js");
+var import_xml2js3 = require("xml2js");
 var import_stream = require("stream");
 var xlsx = __toESM(require("xlsx"));
 function useAccessManagementSvc() {
@@ -31713,7 +31826,7 @@ function useAccessManagementSvc() {
     try {
       const command = readTemplate("door-levels");
       const response = await sendCommand(command, params.acm_url);
-      const res = await (0, import_xml2js2.parseStringPromise)(response, { explicitArray: false });
+      const res = await (0, import_xml2js3.parseStringPromise)(response, { explicitArray: false });
       const format = await formatDoorAccessLevels(res);
       return format;
     } catch (err) {
@@ -31724,7 +31837,7 @@ function useAccessManagementSvc() {
     try {
       const command = readTemplate("lift-levels");
       const response = await sendCommand(command, params.acm_url);
-      const res = await (0, import_xml2js2.parseStringPromise)(response, { explicitArray: false });
+      const res = await (0, import_xml2js3.parseStringPromise)(response, { explicitArray: false });
       const format = await formatLiftAccessLevels(res);
       return format;
     } catch (error) {
@@ -31735,7 +31848,7 @@ function useAccessManagementSvc() {
     try {
       const command = readTemplate("access-group");
       const response = await sendCommand(command, params.acm_url);
-      const res = await (0, import_xml2js2.parseStringPromise)(response, { explicitArray: false });
+      const res = await (0, import_xml2js3.parseStringPromise)(response, { explicitArray: false });
       const format = await formatAccessGroup(res);
       return format;
     } catch (err) {
@@ -32781,6 +32894,9 @@ function useAccessManagementController() {
       });
     }
   };
+  const removeAccessCard = async ({ cardNo, staffNo, url }) => {
+    return removeAccessGroup({ cardNo, staffNo, url });
+  };
   return {
     addPhysicalCard,
     addNonPhysicalCard,
@@ -32811,7 +32927,8 @@ function useAccessManagementController() {
     vmsgenerateQrCodes,
     addVisitorAccessCard,
     signQrCode,
-    checkoutVisitor
+    checkoutVisitor,
+    removeAccessCard
   };
 }
 
@@ -33326,6 +33443,7 @@ function MOccurrenceBook(value) {
 // src/repositories/occurrence-book.repo.ts
 var import_node_server_utils155 = require("@7365admin1/node-server-utils");
 var import_mongodb88 = require("mongodb");
+var occurrence_book_namespace_collection = "occurrence-books";
 function useOccurrenceBookRepo() {
   const db = import_node_server_utils155.useAtlas.getDb();
   if (!db) {
@@ -33353,18 +33471,21 @@ function useOccurrenceBookRepo() {
       );
     }
   }
-  const namespace_collection = "occurrence-books";
-  const collection = db.collection(namespace_collection);
-  const { delNamespace, getCache, setCache } = (0, import_node_server_utils155.useCache)(namespace_collection);
+  const collection = db.collection(occurrence_book_namespace_collection);
+  const { delNamespace, getCache, setCache } = (0, import_node_server_utils155.useCache)(
+    occurrence_book_namespace_collection
+  );
   async function add(value, session) {
     try {
       value = MOccurrenceBook(value);
       const res = await collection.insertOne(value, { session });
       delNamespace().then(() => {
-        import_node_server_utils155.logger.info(`Cache cleared for namespace: ${namespace_collection}`);
+        import_node_server_utils155.logger.info(
+          `Cache cleared for namespace: ${occurrence_book_namespace_collection}`
+        );
       }).catch((err) => {
         import_node_server_utils155.logger.error(
-          `Failed to clear cache for namespace: ${namespace_collection}`,
+          `Failed to clear cache for namespace: ${occurrence_book_namespace_collection}`,
           err
         );
       });
@@ -33447,7 +33568,10 @@ function useOccurrenceBookRepo() {
       query.$text = { $search: search };
       cacheOptions.search = search;
     }
-    const cacheKey = (0, import_node_server_utils155.makeCacheKey)(namespace_collection, cacheOptions);
+    const cacheKey = (0, import_node_server_utils155.makeCacheKey)(
+      occurrence_book_namespace_collection,
+      cacheOptions
+    );
     const cachedData = await getCache(cacheKey);
     if (cachedData) {
       import_node_server_utils155.logger.info(`Cache hit for key: ${cacheKey}`);
@@ -33481,7 +33605,9 @@ function useOccurrenceBookRepo() {
     } catch (error) {
       throw new import_node_server_utils155.BadRequestError("Invalid occurrence book ID format.");
     }
-    const cacheKey = (0, import_node_server_utils155.makeCacheKey)(namespace_collection, { _id });
+    const cacheKey = (0, import_node_server_utils155.makeCacheKey)(occurrence_book_namespace_collection, {
+      _id
+    });
     const cachedData = await getCache(cacheKey);
     if (cachedData) {
       import_node_server_utils155.logger.info(`Cache hit for key: ${cacheKey}`);
@@ -33521,10 +33647,12 @@ function useOccurrenceBookRepo() {
         );
       }
       delNamespace().then(() => {
-        import_node_server_utils155.logger.info(`Cache cleared for namespace: ${namespace_collection}`);
+        import_node_server_utils155.logger.info(
+          `Cache cleared for namespace: ${occurrence_book_namespace_collection}`
+        );
       }).catch((err) => {
         import_node_server_utils155.logger.error(
-          `Failed to clear cache for namespace: ${namespace_collection}`,
+          `Failed to clear cache for namespace: ${occurrence_book_namespace_collection}`,
           err
         );
       });
@@ -33550,10 +33678,12 @@ function useOccurrenceBookRepo() {
         throw new import_node_server_utils155.InternalServerError("Unable to delete occurrence book.");
       }
       delNamespace().then(() => {
-        import_node_server_utils155.logger.info(`Cache cleared for namespace: ${namespace_collection}`);
+        import_node_server_utils155.logger.info(
+          `Cache cleared for namespace: ${occurrence_book_namespace_collection}`
+        );
       }).catch((err) => {
         import_node_server_utils155.logger.error(
-          `Failed to clear cache for namespace: ${namespace_collection}`,
+          `Failed to clear cache for namespace: ${occurrence_book_namespace_collection}`,
           err
         );
       });
@@ -33575,10 +33705,12 @@ function useOccurrenceBookRepo() {
         throw new import_node_server_utils155.InternalServerError("Unable to close daily occurrence book.");
       }
       delNamespace().then(() => {
-        import_node_server_utils155.logger.info(`Cache cleared for namespace: ${namespace_collection}`);
+        import_node_server_utils155.logger.info(
+          `Cache cleared for namespace: ${occurrence_book_namespace_collection}`
+        );
       }).catch((err) => {
         import_node_server_utils155.logger.error(
-          `Failed to clear cache for namespace: ${namespace_collection}`,
+          `Failed to clear cache for namespace: ${occurrence_book_namespace_collection}`,
           err
         );
       });
@@ -33587,6 +33719,47 @@ function useOccurrenceBookRepo() {
       throw error;
     }
   }
+  async function bulkCreate(payloads, session) {
+    try {
+      if (!payloads.length) {
+        return { insertedCount: 0 };
+      }
+      const chunkSize = 500;
+      let totalInserted = 0;
+      for (let i = 0; i < payloads.length; i += chunkSize) {
+        const chunk = payloads.slice(i, i + chunkSize);
+        const operations = chunk.map((item) => ({
+          insertOne: {
+            document: {
+              ...item,
+              createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+              updatedAt: "",
+              deletedAt: ""
+            }
+          }
+        }));
+        const result = await collection.bulkWrite(operations, { session });
+        totalInserted += result.insertedCount || 0;
+      }
+      import_node_server_utils155.logger.info(
+        `Bulk insert successful: ${totalInserted} occurrence books created.`
+      );
+      delNamespace().then(() => {
+        import_node_server_utils155.logger.info(
+          `Cache cleared for namespace: ${occurrence_book_namespace_collection}`
+        );
+      }).catch((err) => {
+        import_node_server_utils155.logger.error(
+          `Failed to clear cache for namespace: ${occurrence_book_namespace_collection}`,
+          err
+        );
+      });
+      return { insertedCount: totalInserted };
+    } catch (error) {
+      import_node_server_utils155.logger.error("Bulk insert failed for occurrence books", error);
+      throw error;
+    }
+  }
   return {
     add,
     getAll,
@@ -33595,7 +33768,8 @@ function useOccurrenceBookRepo() {
     deleteOccurrenceBookById,
     closeOccurrenceBooks,
     createIndexes,
-    createTextIndex
+    createTextIndex,
+    bulkCreate
   };
 }
 
@@ -33605,14 +33779,18 @@ function useOccurrenceBookService() {
   const {
     add: _add,
     updateOccurrenceBookById: _updateOccurrenceBookById,
-    closeOccurrenceBooks: _closeOccurrenceBooks
+    closeOccurrenceBooks: _closeOccurrenceBooks,
+    bulkCreate: _bulkCreate
   } = useOccurrenceBookRepo();
   const {
     add: _addOccurrenceCounter,
     incrementByType: _incrementByType,
     getByType: _getByType
   } = useCounterRepo();
-  const { getAllSites: _getAllSites } = useSiteRepo();
+  const {
+    getAllSites: _getAllSites,
+    getAllSitesUnpaginated: _getAllSitesUnpaginated
+  } = useSiteRepo();
   async function add(value) {
     const session = import_node_server_utils156.useAtlas.getClient()?.startSession();
     session?.startTransaction();
@@ -33650,39 +33828,31 @@ function useOccurrenceBookService() {
     }
   }
   async function processCreateDOB() {
-    const limit = 100;
     const counterName = "occurrence-book";
-    let page = 1;
     let entryCounter = 0;
     const session = import_node_server_utils156.useAtlas.getClient()?.startSession();
-    session?.startTransaction();
-    const existingCounter = await _getByType(counterName);
-    if (!existingCounter) {
-      await _addOccurrenceCounter(counterName);
-    } else {
-      await _incrementByType(counterName, session);
-      entryCounter = existingCounter.count + 1;
-    }
-    const baseDate = /* @__PURE__ */ new Date();
-    baseDate.setUTCMinutes(0, 0, 0);
-    const closedAt = new Date(baseDate);
-    closedAt.setUTCDate(closedAt.getUTCDate() + 3);
     try {
-      while (true) {
-        const sites = await _getAllSites({ page, limit });
-        if (sites.items.length === 0)
-          break;
-        for (const site of sites.items) {
-          const occurenceBookPayload = {
-            site: site._id,
-            date: baseDate.toISOString(),
-            closedAt: closedAt.toISOString(),
-            entryCounter
-          };
-          await _add(occurenceBookPayload, session);
-        }
-        page++;
-      }
+      session?.startTransaction();
+      const existingCounter = await _getByType(counterName);
+      if (!existingCounter) {
+        await _addOccurrenceCounter(counterName);
+        entryCounter = 1;
+      } else {
+        entryCounter = existingCounter.count + 1;
+        await _incrementByType(counterName);
+      }
+      const baseDate = /* @__PURE__ */ new Date();
+      baseDate.setUTCMinutes(0, 0, 0);
+      const closedAt = new Date(baseDate);
+      closedAt.setUTCDate(closedAt.getUTCDate() + 3);
+      const sites = await _getAllSitesUnpaginated();
+      const payloads = sites.map((site) => ({
+        site: site._id,
+        date: baseDate.toISOString(),
+        closedAt: closedAt.toISOString(),
+        entryCounter
+      }));
+      await _bulkCreate(payloads, session);
       await session?.commitTransaction();
     } catch (err) {
       await session?.abortTransaction();
@@ -40658,7 +40828,7 @@ function useManpowerMonitoringRepo() {
   if (!db) {
     throw new Error("Unable to connect to server.");
   }
-  const namespace_collection = "manpower-monitoring";
+  const namespace_collection = "manpower-settings";
   const collection = db.collection(namespace_collection);
   const serviceProviderCollection = db.collection("site.service-providers");
   async function createManpowerMonitoringSettings(value, session) {
@@ -41601,7 +41771,7 @@ function useOvernightParkingRepo() {
     try {
       const data = await collection.findOne({
         site: siteId,
-        deletedAt: null
+        deletedAt: { $nin: ["", null] }
       });
       setCache(cacheKey, data, 15 * 60).then(() => {
         import_node_server_utils200.logger.info(`Cache set for key: ${cacheKey}`);
@@ -41709,12 +41879,12 @@ var schemaOvernightParkingRequest = import_joi118.default.object({
   numberOfPassengers: import_joi118.default.number().integer().min(0).optional().default(0),
   purposeOfVisit: import_joi118.default.string().optional().allow("", null),
   status: import_joi118.default.string().valid(...Object.values(OvernightParkingRequestStatus)).optional().allow(null, "").default("pending" /* PENDING */),
-  comment: import_joi118.default.string().optional().allow(null, "")
+  remarks: import_joi118.default.string().optional().allow(null, "")
 });
 var schemaUpdateOvernightParkingRequest = import_joi118.default.object({
   _id: import_joi118.default.string().hex().length(24).required(),
   status: import_joi118.default.string().valid(...Object.values(OvernightParkingRequestStatus)).required(),
-  comment: import_joi118.default.string().optional().allow(null, "")
+  remarks: import_joi118.default.string().optional().allow(null, "")
 });
 function MOvernightParkingRequest(value) {
   const { error } = schemaOvernightParkingRequest.validate(value);
@@ -41746,6 +41916,30 @@ function useOvernightParkingRequestRepo() {
   const { delNamespace, getCache, setCache } = (0, import_node_server_utils203.useCache)(
     overnight_parking_requests_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_utils203.InternalServerError("Failed to create collection indexes.");
+    }
+  }
   async function add(value, session) {
     try {
       value = MOvernightParkingRequest(value);
@@ -41931,7 +42125,8 @@ function useOvernightParkingRequestRepo() {
     getOvernightParkingRequestById,
     updateOvernightParkingRequestById,
     deleteOvernightParkingRequestById,
-    updateExpiredRequests
+    updateExpiredRequests,
+    createIndexes
   };
 }
 
@@ -43068,6 +43263,691 @@ function useManpowerRemarkCtrl() {
     updateRemarksStatus
   };
 }
+
+// src/models/manpower-sites.model.ts
+var import_joi122 = __toESM(require("joi"));
+var import_mongodb114 = require("mongodb");
+var manpowerSitesSchema = import_joi122.default.object({
+  id: import_joi122.default.string().hex().required(),
+  text: import_joi122.default.string().hex().optional().allow("", null),
+  contractID: import_joi122.default.string().optional().allow("", null),
+  contractName: import_joi122.default.string().optional().allow("", null),
+  type: import_joi122.default.string().optional().allow("", null),
+  status: import_joi122.default.number().optional().allow("", null)
+});
+var MManpowerSites = class {
+  constructor(data) {
+    this._id = new import_mongodb114.ObjectId();
+    this.id = data.id || "";
+    this.text = data.text || "";
+    this.contractID = data.contractID || "";
+    this.contractName = data.contractName || "";
+    this.type = data.type || "";
+    this.status = data.status || "";
+  }
+};
+
+// src/repositories/manpower-sites.repo.ts
+var import_node_server_utils209 = require("@7365admin1/node-server-utils");
+function useManpowerSitesRepo() {
+  const db = import_node_server_utils209.useAtlas.getDb();
+  if (!db) {
+    throw new Error("Unable to connect to server.");
+  }
+  const namespace_collection = "manpower-sites";
+  const collection = db.collection(namespace_collection);
+  async function createManpowerSites(value) {
+    try {
+      value = new MManpowerSites(value);
+      const result = await collection.insertOne(value);
+      return result;
+    } catch (error) {
+      throw new Error(error.message || error || "Server Internal Error");
+    }
+  }
+  async function getAllManpowerSites({
+    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 } },
+              {
+                $project: {
+                  _id: 0
+                }
+              },
+              { $skip: page * limit },
+              { $limit: limit }
+            ]
+          }
+        }
+      ]).toArray();
+      const items = result[0].items;
+      return items;
+    } catch (error) {
+      throw new Error(error.message || "Server Internal Error");
+    }
+  }
+  async function deleteManpowerSites(siteId) {
+    try {
+      const result = await collection.deleteOne({
+        id: siteId.toString()
+      });
+      return result;
+    } catch (error) {
+      throw new Error(error.message || "Server Internal Error");
+    }
+  }
+  return {
+    createManpowerSites,
+    getAllManpowerSites,
+    deleteManpowerSites
+  };
+}
+
+// src/services/manpower-sites.service.ts
+var import_node_server_utils210 = require("@7365admin1/node-server-utils");
+function useManpowerSitesSrvc() {
+  const manpowerSitesRepo = useManpowerSitesRepo();
+  const manpowerMonitoringRepo = useManpowerMonitoringRepo();
+  async function createManpowerSites(payload) {
+    const session = import_node_server_utils210.useAtlas.getClient()?.startSession();
+    if (!session) {
+      throw new import_node_server_utils210.BadRequestError("Database session not available.");
+    }
+    await session.startTransaction();
+    try {
+      const manpowerSites = await manpowerMonitoringRepo.getAllSites(payload);
+      for (const site of manpowerSites) {
+        await manpowerSitesRepo.createManpowerSites(site);
+      }
+      await session.commitTransaction();
+      return "Created Succesfully";
+    } catch (error) {
+      await session.abortTransaction();
+      import_node_server_utils210.logger.error(error.message || error);
+      console.error("Error creating monitoring settings:", error);
+      throw new Error(error?.message || "Internal Server Error!");
+    } finally {
+      session.endSession();
+    }
+  }
+  async function checkManpowerSites() {
+    try {
+      const serviceProviderId = "69bb9dbff572cf9d260d7ce3";
+      const hrmLabsSites = await manpowerMonitoringRepo.getAllSites(
+        serviceProviderId
+      );
+      const manpowerSites = await manpowerSitesRepo.getAllManpowerSites({
+        page: 1,
+        limit: 1e3,
+        search: ""
+      });
+      const added = hrmLabsSites.filter(
+        (hrmSite) => !manpowerSites.some((mpSite) => mpSite.id === hrmSite.id)
+      );
+      const deleted = manpowerSites.filter(
+        (mpSite) => !hrmLabsSites.some((hrmSite) => hrmSite.id === mpSite.id)
+      );
+      if (added.length > 0) {
+        await Promise.all(
+          added.map((site) => manpowerSitesRepo.createManpowerSites(site))
+        );
+      }
+      if (deleted.length > 0) {
+        await Promise.all(
+          deleted.map(
+            (site) => manpowerSitesRepo.deleteManpowerSites(site.id)
+          )
+        );
+      }
+      return "Manpower Sites Updated Successfully";
+    } catch (error) {
+      import_node_server_utils210.logger.error(error.message || error);
+      console.error("Error checking manpower sites:", error);
+      throw new Error(error?.message || "Internal Server Error!");
+    }
+  }
+  return {
+    createManpowerSites,
+    checkManpowerSites
+  };
+}
+
+// src/controllers/manpower-sites.controller.ts
+var import_node_server_utils211 = require("@7365admin1/node-server-utils");
+var import_joi123 = __toESM(require("joi"));
+function useManpowerSitesCtrl() {
+  const { createManpowerSites: _createManpowerSites } = useManpowerSitesSrvc();
+  const { getAllManpowerSites: _getAllManpowerSites } = useManpowerSitesRepo();
+  async function createManpowerSites(req, res, next) {
+    try {
+      const payload = req.query.serviceProviderId;
+      const schema2 = import_joi123.default.object({
+        serviceProviderId: import_joi123.default.string().hex().required()
+      });
+      const { error } = schema2.validate({
+        serviceProviderId: payload
+      });
+      if (error) {
+        next(new import_node_server_utils211.BadRequestError(error.message));
+        return;
+      }
+      const result = await _createManpowerSites(payload);
+      return res.json(result);
+    } catch (error) {
+      import_node_server_utils211.logger.log({ level: "error", message: error.message });
+      next(error);
+      return;
+    }
+  }
+  async function getAllManpowerSites(req, res, next) {
+    try {
+      const { page, search, limit } = req.query;
+      const schema2 = import_joi123.default.object({
+        page: import_joi123.default.number().optional().allow("", null),
+        limit: import_joi123.default.number().optional().allow("", null),
+        search: import_joi123.default.string().optional().allow("", null)
+      });
+      const { error } = schema2.validate({ page, search, limit });
+      if (error) {
+        next(new import_node_server_utils211.BadRequestError(error.message));
+        return;
+      }
+      const result = await _getAllManpowerSites({
+        page: Number(page),
+        limit: Number(limit),
+        search
+      });
+      return res.json(result);
+    } catch (error) {
+      import_node_server_utils211.logger.log({ level: "error", message: error.message });
+      next(error);
+      return;
+    }
+  }
+  return {
+    createManpowerSites,
+    getAllManpowerSites
+  };
+}
+
+// src/utils/cron.util.ts
+var import_node_server_utils212 = require("@7365admin1/node-server-utils");
+var import_mongodb115 = require("mongodb");
+var import_moment_timezone4 = __toESM(require("moment-timezone"));
+var createManpowerRemarksDaily = async () => {
+  const db = import_node_server_utils212.useAtlas.getDb();
+  if (!db) {
+    throw new Error("Unable to connect to server.");
+  }
+  const namespace_collection = "manpower-settings";
+  const settings = db.collection(namespace_collection);
+  const remarks = db.collection("manpower-remarks");
+  const serviceProviders = db.collection("site.service-providers");
+  const items = [];
+  const yesterday = (0, import_moment_timezone4.default)().tz("Asia/Singapore").subtract(1, "days").format("DD-MM-YYYY");
+  try {
+    const nowSGT = (0, import_moment_timezone4.default)().tz("Asia/Singapore");
+    const servideProvider = await serviceProviders.findOne({
+      name: { $regex: process.env.HRMLABS_DOMAIN, $options: "i" }
+    });
+    if (!servideProvider) {
+      throw new Error("Servide Provider not found.");
+    }
+    const remark = await remarks.find({
+      createdAtSGT: yesterday,
+      serviceProviderId: servideProvider._id,
+      status: "active"
+    }).toArray();
+    for (const site of remark) {
+      const existingRemark = await settings.findOne({
+        siteId: site.siteId,
+        enabled: true
+      });
+      if (existingRemark) {
+        const setting = await settings.findOne({
+          siteId: site.siteId,
+          enabled: true
+        });
+        const shiftType = setting?.shiftType;
+        const morningCheckInTime = setting?.shifts?.[shiftType][0]?.checkIn;
+        const afternoonCheckInTime = shiftType == "3-shifts" ? setting?.shifts?.[shiftType][1]?.checkIn : null;
+        const nightCheckInTime = shiftType == "3-shifts" ? setting?.shifts?.[shiftType][2]?.checkIn : setting?.shifts?.[shiftType][1]?.checkIn;
+        const morningAlertFrequencyMins = setting?.shifts?.[shiftType][0]?.alertFrequencyMins;
+        const afternoonAlertFrequencyMins = shiftType == "3-shifts" ? setting?.shifts?.[shiftType][1]?.alertFrequencyMins : null;
+        const nightAlertFrequencyMins = shiftType == "3-shifts" ? setting?.shifts?.[shiftType][2]?.alertFrequencyMins : setting?.shifts?.[shiftType][1]?.alertFrequencyMins;
+        const morningAlertTime = import_moment_timezone4.default.tz(morningCheckInTime, "HH:mm", "Asia/Singapore").add(morningAlertFrequencyMins, "minutes").format("HH:mm");
+        const afternoonAlertTime = afternoonCheckInTime ? import_moment_timezone4.default.tz(afternoonCheckInTime, "HH:mm", "Asia/Singapore").add(afternoonAlertFrequencyMins, "minutes").format("HH:mm") : "";
+        const nightAlertTime = import_moment_timezone4.default.tz(nightCheckInTime, "HH:mm", "Asia/Singapore").add(nightAlertFrequencyMins, "minutes").format("HH:mm");
+        const remark2 = {
+          siteId: site.siteId,
+          siteName: site.siteName,
+          serviceProviderId: servideProvider._id,
+          remarks: [
+            {
+              name: "Morning Shift",
+              remark: {
+                isAcknowledged: true,
+                status: "",
+                acknowledgementRemarks: "",
+                acknowledgedAt: ""
+              }
+            },
+            {
+              name: "Afternoon Shift",
+              remark: {
+                isAcknowledged: true,
+                status: "",
+                acknowledgementRemarks: "",
+                acknowledgedAt: ""
+              }
+            },
+            {
+              name: "Night Shift",
+              remark: {
+                isAcknowledged: true,
+                status: "",
+                acknowledgementRemarks: "",
+                acknowledgedAt: ""
+              }
+            }
+          ],
+          createdBy: "",
+          createdByName: "",
+          morningAlertTime,
+          afternoonAlertTime,
+          nightAlertTime,
+          createdAt: /* @__PURE__ */ new Date(),
+          createdAtSGT: nowSGT.format("DD-MM-YYYY"),
+          updatedAt: "",
+          status: "active"
+        };
+        items.push(remark2);
+      }
+    }
+    if (items.length > 0) {
+      await remarks.insertMany(items);
+    }
+    console.log("Daily manpower remarks created successfully.");
+  } catch (error) {
+    console.error("Error creating daily manpower remarks:", error);
+  }
+};
+var updateRemarksisAcknowledged = async () => {
+  const { getAttendanceDataCount: _getAttendanceDataCount } = useHrmLabsAttendanceSrvc();
+  const nowSGT = (0, import_moment_timezone4.default)().tz("Asia/Singapore").format("DD-MM-YYYY");
+  const db = import_node_server_utils212.useAtlas.getDb();
+  if (!db) {
+    throw new Error("Unable to connect to server.");
+  }
+  const namespace_collection = "manpower-remarks";
+  const remarks = db.collection(namespace_collection);
+  const timeNow = (0, import_moment_timezone4.default)().tz("Asia/Singapore").format("HH:mm");
+  const settings = db.collection("manpower-settings");
+  try {
+    const matchingDocs = await remarks.find({
+      createdAtSGT: nowSGT,
+      $or: [
+        {
+          morningAlertTime: timeNow,
+          "remarks.0.remark.isAcknowledged": true
+        },
+        {
+          afternoonAlertTime: timeNow,
+          "remarks.1.remark.isAcknowledged": true
+        },
+        { nightAlertTime: timeNow, "remarks.2.remark.isAcknowledged": true }
+      ]
+    }).project({ _id: 1 }).toArray();
+    if (matchingDocs.length === 0) {
+      return;
+    }
+    const updatedIds = matchingDocs.map((doc) => doc._id);
+    await remarks.updateMany(
+      {
+        _id: { $in: updatedIds },
+        morningAlertTime: timeNow,
+        createdAtSGT: nowSGT,
+        "remarks.0.remark.isAcknowledged": true
+      },
+      { $set: { "remarks.0.remark.isAcknowledged": false } }
+    );
+    await remarks.updateMany(
+      {
+        _id: { $in: updatedIds },
+        afternoonAlertTime: timeNow,
+        createdAtSGT: nowSGT,
+        "remarks.1.remark.isAcknowledged": true
+      },
+      { $set: { "remarks.1.remark.isAcknowledged": false } }
+    );
+    await remarks.updateMany(
+      {
+        _id: { $in: updatedIds },
+        nightAlertTime: timeNow,
+        createdAtSGT: nowSGT,
+        "remarks.2.remark.isAcknowledged": true
+      },
+      { $set: { "remarks.2.remark.isAcknowledged": false } }
+    );
+    for (const id of updatedIds) {
+      const doc = await remarks.findOne({ _id: id });
+      const setting = await settings.findOne(
+        { siteId: new import_mongodb115.ObjectId(doc?.siteId) },
+        { projection: { emails: 1 } }
+      );
+      const payload = {
+        startDate: doc?.createdAtSGT,
+        endDate: doc?.createdAtSGT,
+        siteName: doc?.siteName,
+        siteId: doc?.siteId.toString(),
+        serviceProviderId: doc?.serviceProviderId.toString()
+      };
+      const result = await _getAttendanceDataCount(payload);
+      const shifts = [
+        { key: "dayShift", alertTime: doc?.morningAlertTime },
+        { key: "afternoonShift", alertTime: doc?.afternoonAlertTime },
+        { key: "nightShift", alertTime: doc?.nightAlertTime }
+      ];
+      let shiftType;
+      let actual = 0;
+      let expected = 0;
+      for (const shift of shifts) {
+        if (shift.alertTime && isWithinHour(shift.alertTime, timeNow)) {
+          shiftType = shift.key;
+          actual = result?.totalCount?.[shift.key]?.actual || 0;
+          expected = result?.totalCount?.[shift.key]?.expected || 0;
+          break;
+        }
+      }
+      let newStatus = "Normal";
+      if (actual > expected)
+        newStatus = "Over";
+      else if (actual < expected)
+        newStatus = "Under";
+      sendEmailWithAttachmentsTo({
+        email: setting?.emails,
+        subject: "Manpower Alert",
+        message: "",
+        siteName: doc?.siteName || "",
+        handlebar: "alert-email",
+        date: nowSGT,
+        actual,
+        expected,
+        status: newStatus
+      });
+    }
+  } catch (error) {
+    console.error("Error updating remarks:", error);
+  }
+};
+var updateRemarksStatusEod = async () => {
+  const { getAttendanceDataCount: _getAttendanceDataCount } = useHrmLabsAttendanceSrvc();
+  const db = import_node_server_utils212.useAtlas.getDb();
+  if (!db) {
+    throw new Error("Unable to connect to server.");
+  }
+  const remarks = db.collection("manpower-remarks");
+  const settings = db.collection("manpower-settings");
+  const nowSGT = (0, import_moment_timezone4.default)().tz("Asia/Singapore").format("DD-MM-YYYY");
+  const yesterdaySGT = (0, import_moment_timezone4.default)().tz("Asia/Singapore").subtract(1, "days").format("DD-MM-YYYY");
+  const timeNow = (0, import_moment_timezone4.default)().tz("Asia/Singapore").format("HH:mm");
+  const docs = await remarks.find({
+    $or: [
+      // Morning & Afternoon from today
+      {
+        createdAtSGT: nowSGT,
+        $or: [
+          {
+            "remarks.0.remark.status": "",
+            "remarks.0.remark.isAcknowledged": false
+          },
+          {
+            "remarks.1.remark.status": "",
+            "remarks.1.remark.isAcknowledged": false
+          }
+        ]
+      },
+      // Night shift from yesterday
+      {
+        createdAtSGT: yesterdaySGT,
+        "remarks.2.remark.status": "",
+        "remarks.2.remark.isAcknowledged": false
+      }
+    ]
+  }).toArray();
+  for (const doc of docs) {
+    let shiftsToCheck = [];
+    const endShiftTime = await settings.findOne(
+      { siteId: new import_mongodb115.ObjectId(doc.siteId) },
+      { projection: { shifts: 1, shiftType: 1 } }
+    );
+    if (doc.createdAtSGT === nowSGT) {
+      const shiftType = endShiftTime?.shiftType || "2-shifts";
+      if (timeNow >= endShiftTime?.shifts[shiftType][0]?.checkOut)
+        shiftsToCheck.push({ index: 0, key: "dayShift" });
+      if (shiftType == "3-shifts" && timeNow >= endShiftTime?.shifts[shiftType][1]?.checkOut)
+        shiftsToCheck.push({ index: 1, key: "afternoonShift" });
+    }
+    if (doc.createdAtSGT === yesterdaySGT) {
+      const index = endShiftTime?.shiftType === "2-shifts" ? 1 : 2;
+      if (timeNow >= endShiftTime?.shifts[endShiftTime?.shiftType][index]?.checkOut)
+        shiftsToCheck.push({ index: 2, key: "nightShift" });
+    }
+    if (shiftsToCheck.length === 0)
+      continue;
+    const payload = {
+      startDate: doc.createdAtSGT,
+      endDate: doc.createdAtSGT,
+      siteName: doc.siteName,
+      siteId: doc.siteId.toString(),
+      serviceProviderId: doc.serviceProviderId.toString()
+    };
+    const result = await _getAttendanceDataCount(payload);
+    if (!result?.totalCount) {
+      continue;
+    }
+    for (const shift of shiftsToCheck) {
+      const actual = result?.totalCount[shift?.key]?.actual || 0;
+      const expected = result?.totalCount[shift?.key]?.expected || 0;
+      if (doc.remarks[shift.index].remark.status === "") {
+        let newStatus = "Normal";
+        if (actual > expected)
+          newStatus = "Over";
+        else if (actual < expected)
+          newStatus = "Under";
+        await remarks.updateOne(
+          { _id: doc._id },
+          {
+            $set: {
+              [`remarks.${shift.index}.remark.status`]: newStatus,
+              [`remarks.${shift.index}.remark.isAcknowledged`]: true,
+              [`remarks.${shift.index}.remark.acknowledgedAt`]: (/* @__PURE__ */ new Date()).toISOString()
+            }
+          }
+        );
+      }
+    }
+  }
+};
+function sendEmailWithAttachmentsTo({
+  email = "",
+  subject = "",
+  message = "",
+  siteName = "",
+  handlebar = "",
+  date = "",
+  actual = 0,
+  expected = 0,
+  status = ""
+}) {
+  const MailerConfig = {
+    host: MAILER_TRANSPORT_HOST,
+    port: MAILER_TRANSPORT_PORT,
+    secure: MAILER_TRANSPORT_SECURE,
+    email: MAILER_EMAIL,
+    password: MAILER_PASSWORD
+  };
+  const mailer = new import_node_server_utils212.useMailer(MailerConfig);
+  const dir = __dirname;
+  const type = "alert-email";
+  const filePath = (0, import_node_server_utils212.getDirectory)(dir, `./public/handlebars/${type}`);
+  const emailContent = (0, import_node_server_utils212.compileHandlebar)({
+    context: {
+      siteName,
+      date,
+      actual,
+      expected,
+      status
+    },
+    filePath
+  });
+  mailer.sendMail({
+    to: email,
+    subject,
+    html: emailContent,
+    sender: "iService365"
+  }).catch((error) => {
+    import_node_server_utils212.logger.log({
+      level: "error",
+      message: `Error sending user ${type} email: ${error}`
+    });
+  });
+  return { message };
+}
+var isWithinHour = (alertTime, timeNow) => {
+  const [ah, am] = alertTime.split(":").map(Number);
+  const [nh, nm] = timeNow.split(":").map(Number);
+  const alertMinutes = ah * 60 + am;
+  const nowMinutes = nh * 60 + nm;
+  return nowMinutes >= alertMinutes && nowMinutes <= alertMinutes + 60;
+};
+
+// src/events/manpower.event.ts
+var import_node_server_utils213 = require("@7365admin1/node-server-utils");
+var import_mongodb116 = require("mongodb");
+var import_moment_timezone5 = __toESM(require("moment-timezone"));
+async function manpowerEvents(io) {
+  console.log("Manpower events initialized");
+  let intervalId = null;
+  let activeConnections = 0;
+  const { getAttendanceDataCount: _getAttendanceDataCount } = useHrmLabsAttendanceSrvc();
+  const updateRemarksStatus = async (date) => {
+    const db = import_node_server_utils213.useAtlas.getDb();
+    if (!db) {
+      throw new Error("Unable to connect to server.");
+    }
+    const remarks = db.collection("manpower-remarks");
+    const settings = db.collection("manpower-settings");
+    const selectedDateMoment = import_moment_timezone5.default.tz(date, "DD-MM-YYYY", "Asia/Singapore");
+    const selectedDateSGT = selectedDateMoment.format("DD-MM-YYYY");
+    const currentSGT = (0, import_moment_timezone5.default)().tz("Asia/Singapore");
+    const docs = await remarks.find({
+      createdAtSGT: selectedDateSGT,
+      $or: [
+        { "remarks.0.remark.status": "" },
+        { "remarks.1.remark.status": "" },
+        { "remarks.2.remark.status": "" }
+      ]
+    }).toArray();
+    for (const doc of docs) {
+      const siteSettings = await settings.findOne(
+        { siteId: new import_mongodb116.ObjectId(doc.siteId), enabled: true },
+        { projection: { shifts: 1, shiftType: 1 } }
+      );
+      const shiftType = siteSettings?.shiftType || "2-shifts";
+      const shiftsToCheck = [];
+      shiftsToCheck.push({ index: 0, key: "dayShift" });
+      if (shiftType === "3-shifts") {
+        shiftsToCheck.push({ index: 1, key: "afternoonShift" });
+      }
+      if (currentSGT.isSame(selectedDateMoment, "day")) {
+        if (currentSGT.isSameOrAfter(
+          import_moment_timezone5.default.tz("19:55", "HH:mm", "Asia/Singapore")
+        )) {
+          shiftsToCheck.push({ index: 2, key: "nightShift" });
+        }
+      } else if (currentSGT.isAfter(selectedDateMoment, "day")) {
+        shiftsToCheck.push({ index: 2, key: "nightShift" });
+      }
+      if (shiftsToCheck.length === 0)
+        continue;
+      const payload = {
+        startDate: doc.createdAtSGT,
+        endDate: doc.createdAtSGT,
+        siteName: doc.siteName,
+        siteId: doc.siteId.toString(),
+        serviceProviderId: doc.serviceProviderId.toString()
+      };
+      const result = await _getAttendanceDataCount(payload);
+      for (const shift of shiftsToCheck) {
+        const actual = result?.totalCount?.[shift.key]?.actual || 0;
+        const expected = result?.totalCount?.[shift.key]?.expected || 0;
+        let newStatus = "Normal";
+        if (actual > expected)
+          newStatus = "Over";
+        else if (actual < expected)
+          newStatus = "Under";
+        const namespace = `/manpower`;
+        io.of(namespace).emit("manpower-status-update", {
+          siteId: doc.siteId,
+          siteName: doc.siteName,
+          shift: shift.key,
+          status: newStatus,
+          actual,
+          expected,
+          selectedDateSGT
+        });
+      }
+    }
+  };
+  const startInterval = (date) => {
+    if (!intervalId) {
+      intervalId = setInterval(
+        () => updateRemarksStatus(date?.toString() || ""),
+        15 * 1e3
+      );
+      console.log(" Interval started.");
+    }
+  };
+  const stopInterval = () => {
+    if (intervalId) {
+      clearInterval(intervalId);
+      intervalId = null;
+      console.log(" Interval stopped.");
+    }
+  };
+  io.of("/manpower").on("connection", (socket) => {
+    activeConnections += 1;
+    const date = socket.handshake.query.date;
+    if (activeConnections === 1) {
+      startInterval(date?.toString() || "");
+    }
+    updateRemarksStatus(date?.toString() || "");
+    socket.on("disconnect", () => {
+      activeConnections -= 1;
+      console.log(`Client disconnected: ${socket.id}`);
+      console.log(`Total active connections: ${activeConnections}`);
+      if (activeConnections === 0) {
+        stopInterval();
+      }
+    });
+  });
+}
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   ANPRMode,
@@ -43109,6 +43989,7 @@ function useManpowerRemarkCtrl() {
   MManpowerDesignations,
   MManpowerMonitoring,
   MManpowerRemarks,
+  MManpowerSites,
   MMember,
   MNfcPatrolLog,
   MNfcPatrolRoute,
@@ -43174,6 +44055,7 @@ function useManpowerRemarkCtrl() {
   bulletin_boards_namespace_collection,
   calculatePercentage,
   chatSchema,
+  createManpowerRemarksDaily,
   customerSchema,
   designationsSchema,
   events_namespace_collection,
@@ -43188,10 +44070,13 @@ function useManpowerRemarkCtrl() {
   landscapeDashboardCollection,
   mAndEDashboardCollection,
   manpowerDesignationsSchema,
+  manpowerEvents,
   manpowerMonitoringSchema,
   manpowerRemarksSchema,
+  manpowerSitesSchema,
   nfcPatrolSettingsSchema,
   nfcPatrolSettingsSchemaUpdate,
+  occurrence_book_namespace_collection,
   orgSchema,
   overnight_parking_requests_namespace_collection,
   pestDashboardCollection,
@@ -43272,6 +44157,8 @@ function useManpowerRemarkCtrl() {
   siteSchema,
   site_people_namespace_collection,
   tokenSchema,
+  updateRemarksStatusEod,
+  updateRemarksisAcknowledged,
   updateSiteSchema,
   useAccessManagementController,
   useAddressRepo,
@@ -43338,6 +44225,9 @@ function useManpowerRemarkCtrl() {
   useManpowerMonitoringSrvc,
   useManpowerRemarkCtrl,
   useManpowerRemarksRepo,
+  useManpowerSitesCtrl,
+  useManpowerSitesRepo,
+  useManpowerSitesSrvc,
   useMemberController,
   useMemberRepo,
   useNewDashboardController,