@7365admin1/core 2.64.0 → 2.66.0

package/dist/index.js

@@ -55,6 +55,7 @@ __export(src_exports, {
   EventType: () => EventType,
   FacilitySort: () => FacilitySort,
   FacilityStatus: () => FacilityStatus,
+  FormEntryStatus: () => FormEntryStatus,
   GuestSort: () => GuestSort,
   GuestStatus: () => GuestStatus,
   MAccessCard: () => MAccessCard,
@@ -76,6 +77,7 @@ __export(src_exports, {
   MEventManagement: () => MEventManagement,
   MFeedback: () => MFeedback,
   MFile: () => MFile,
+  MFormEntry: () => MFormEntry,
   MGuestManagement: () => MGuestManagement,
   MIncidentReport: () => MIncidentReport,
   MManpowerDesignations: () => MManpowerDesignations,
@@ -187,6 +189,7 @@ __export(src_exports, {
   nfcPatrolSettingsSchema: () => nfcPatrolSettingsSchema,
   nfcPatrolSettingsSchemaUpdate: () => nfcPatrolSettingsSchemaUpdate,
   occurrence_book_namespace_collection: () => occurrence_book_namespace_collection,
+  online_forms_namespace_collection: () => online_forms_namespace_collection,
   orgSchema: () => orgSchema,
   overnight_parking_requests_namespace_collection: () => overnight_parking_requests_namespace_collection,
   parseDahuaFind: () => parseDahuaFind,
@@ -211,6 +214,7 @@ __export(src_exports, {
   schemaEntryPassSettings: () => schemaEntryPassSettings,
   schemaEventManagement: () => schemaEventManagement,
   schemaFiles: () => schemaFiles,
+  schemaFormEntry: () => schemaFormEntry,
   schemaGuestManagement: () => schemaGuestManagement,
   schemaIncidentReport: () => schemaIncidentReport,
   schemaNfcPatrolLog: () => schemaNfcPatrolLog,
@@ -241,6 +245,7 @@ __export(src_exports, {
   schemaUpdateDocumentManagement: () => schemaUpdateDocumentManagement,
   schemaUpdateEntryPassSettings: () => schemaUpdateEntryPassSettings,
   schemaUpdateEventManagement: () => schemaUpdateEventManagement,
+  schemaUpdateFormEntry: () => schemaUpdateFormEntry,
   schemaUpdateGuestManagement: () => schemaUpdateGuestManagement,
   schemaUpdateIncidentReport: () => schemaUpdateIncidentReport,
   schemaUpdateOccurrenceBook: () => schemaUpdateOccurrenceBook,
@@ -253,6 +258,7 @@ __export(src_exports, {
   schemaUpdatePatrolQuestion: () => schemaUpdatePatrolQuestion,
   schemaUpdatePatrolRoute: () => schemaUpdatePatrolRoute,
   schemaUpdatePerson: () => schemaUpdatePerson,
+  schemaUpdatePost: () => schemaUpdatePost,
   schemaUpdateServiceProviderBilling: () => schemaUpdateServiceProviderBilling,
   schemaUpdateSiteBillingConfiguration: () => schemaUpdateSiteBillingConfiguration,
   schemaUpdateSiteBillingItem: () => schemaUpdateSiteBillingItem,
@@ -323,6 +329,8 @@ __export(src_exports, {
   useFileController: () => useFileController,
   useFileRepo: () => useFileRepo,
   useFileService: () => useFileService,
+  useFormEntryController: () => useFormEntryController,
+  useFormEntryRepo: () => useFormEntryRepo,
   useGuestManagementController: () => useGuestManagementController,
   useGuestManagementRepo: () => useGuestManagementRepo,
   useGuestManagementService: () => useGuestManagementService,
@@ -587,7 +595,15 @@ var userSchema = import_joi2.default.object({
   email: import_joi2.default.string().email().required(),
   password: import_joi2.default.string().min(8).required(),
   name: import_joi2.default.string().required(),
-  defaultOrg: import_joi2.default.string().hex().optional().allow("", null)
+  defaultOrg: import_joi2.default.string().hex().optional().allow("", null),
+  status: import_joi2.default.string().optional().allow("", null),
+  block: import_joi2.default.number().optional().allow(null),
+  level: import_joi2.default.string().optional().allow("", null),
+  type: import_joi2.default.string().optional().allow("", null),
+  unitName: import_joi2.default.string().optional().allow("", null),
+  contact: import_joi2.default.string().optional().allow("", null),
+  site: import_joi2.default.string().hex().optional().allow("", null),
+  unitId: import_joi2.default.string().hex().optional().allow("", null)
 });
 function MUser(value) {
   const { error } = userSchema.validate(value);
@@ -601,12 +617,33 @@ function MUser(value) {
       throw new import_node_server_utils3.BadRequestError("Invalid default org ID format.");
     }
   }
+  if (value.site && typeof value.site === "string") {
+    try {
+      value.site = new import_mongodb.ObjectId(value.site);
+    } catch {
+      throw new import_node_server_utils3.BadRequestError("Invalid site ID format.");
+    }
+  }
+  if (value.unitId && typeof value.unitId === "string") {
+    try {
+      value.unitId = new import_mongodb.ObjectId(value.unitId);
+    } catch {
+      throw new import_node_server_utils3.BadRequestError("Invalid unit ID format.");
+    }
+  }
   return {
     email: value.email,
     password: value.password,
     name: value.name ?? "",
     defaultOrg: value.defaultOrg ?? "",
-    status: "active" /* ACTIVE */,
+    status: value.status ?? "active" /* ACTIVE */,
+    block: value.block ?? null,
+    level: value.level ?? "",
+    type: value.type ?? "",
+    unitName: value.unitName ?? "",
+    contact: value.contact ?? "",
+    site: value.site ?? "",
+    unitId: value.unitId ?? "",
     createdAt: (/* @__PURE__ */ new Date()).toISOString(),
     updatedAt: value.updatedAt ?? "",
     deletedAt: value.deletedAt ?? ""
@@ -4752,6 +4789,30 @@ function useOrgRepo() {
       throw error;
     }
   }
+  async function getOrgsByEmail(email) {
+    const cacheKey = (0, import_node_server_utils17.makeCacheKey)(namespace_collection, {
+      type: "many",
+      email
+    });
+    const cachedData = await getCache(cacheKey);
+    if (cachedData) {
+      import_node_server_utils17.logger.info(`Cache hit for key: ${cacheKey}`);
+      return cachedData;
+    }
+    try {
+      const data = await collection.find({
+        email
+      }).toArray();
+      setCache(cacheKey, data, 15 * 60).then(() => {
+        import_node_server_utils17.logger.info(`Cache set for key: ${cacheKey}`);
+      }).catch((err) => {
+        import_node_server_utils17.logger.error(`Failed to set cache for key: ${cacheKey}`, err);
+      });
+      return data;
+    } catch (error) {
+      throw error;
+    }
+  }
   async function updateFieldById({
     _id,
     field,
@@ -4854,7 +4915,8 @@ function useOrgRepo() {
     getByEmail,
     updateFieldById,
     updateStatusById,
-    deleteById
+    deleteById,
+    getOrgsByEmail
   };
 }
 
@@ -5854,7 +5916,6 @@ function useVerificationService() {
       await getSiteById(metadata.siteId);
     }
     const verificationIds = [];
-    const invitedApps = [];
     for (const app of apps) {
       await useVerificationRepo().findOne({
         type,
@@ -5877,34 +5938,32 @@ function useVerificationService() {
       };
       const createdId = await add(value);
       verificationIds.push(createdId.toString());
-      invitedApps.push(app);
+      const link = `${APP_MAIN}/verify/invitation/${createdId}`;
+      const emailContent = (0, import_node_server_utils21.compileHandlebar)({
+        context: {
+          email,
+          validity: VERIFICATION_USER_INVITE_DURATION,
+          link,
+          hasPropertyManagement: app === "property_management_agency",
+          hasSecurity: app === "security_agency",
+          hasCleaning: app === "cleaning_services",
+          hasMechanical: app === "mechanical_electrical_services",
+          hasLandscape: app === "landscaping_services",
+          hasPestControl: app === "pest_control_services",
+          hasPoolMaintenance: app === "pool_maintenance_services"
+        },
+        filePath: (0, import_node_server_utils21.getDirectory)(
+          __dirname,
+          "./public/handlebars/user-invite"
+        )
+      });
+      await mailer.sendMail({
+        to: email,
+        subject: "User Invite",
+        html: emailContent,
+        sender: "iService365"
+      });
     }
-    const link = `${APP_MAIN}/verify/invitation/${verificationIds[0]}`;
-    const appsSet = new Set(invitedApps);
-    const emailContent = (0, import_node_server_utils21.compileHandlebar)({
-      context: {
-        email,
-        validity: VERIFICATION_USER_INVITE_DURATION,
-        link,
-        hasPropertyManagement: appsSet.has("property_management_agency"),
-        hasSecurity: appsSet.has("security_agency"),
-        hasCleaning: appsSet.has("cleaning_services"),
-        hasMechanical: appsSet.has("mechanical_electrical_services"),
-        hasLandscape: appsSet.has("landscaping_services"),
-        hasPestControl: appsSet.has("pest_control_services"),
-        hasPoolMaintenance: appsSet.has("pool_maintenance_services")
-      },
-      filePath: (0, import_node_server_utils21.getDirectory)(
-        __dirname,
-        "./public/handlebars/user-invite"
-      )
-    });
-    await mailer.sendMail({
-      to: email,
-      subject: "User Invite",
-      html: emailContent,
-      sender: "iService365"
-    });
     return verificationIds;
   }
   async function createSimpleMemberInvite({
@@ -8374,7 +8433,7 @@ function useVerificationController() {
       siteId: import_joi16.default.string().hex().optional().allow("", null),
       siteName: import_joi16.default.string().optional().allow("", null)
     });
-    const { error } = validation.validate(payload);
+    const { error, value } = validation.validate(payload);
     if (error) {
       import_node_server_utils32.logger.log({
         level: "error",
@@ -8383,15 +8442,17 @@ function useVerificationController() {
       next(new import_node_server_utils32.BadRequestError(error.message));
       return;
     }
-    const email = req.body.email ?? "";
-    const app = req.body.app ?? [];
-    const role = req.body.role ?? "";
-    const name = req.body.name ?? "";
-    const org = req.body.org ?? "";
-    const siteId = req.body.siteId ?? "";
-    const siteName = req.body.siteName ?? "";
     try {
-      await _createSimpleUserInvite({
+      const {
+        email,
+        app,
+        role,
+        name,
+        org,
+        siteId,
+        siteName
+      } = value;
+      const verificationIds = await _createSimpleUserInvite({
         email,
         metadata: {
           app,
@@ -8403,7 +8464,9 @@ function useVerificationController() {
         }
       });
       res.status(201).json({
-        message: "Successfully invited user."
+        message: "Successfully invited user.",
+        totalInvites: verificationIds.length,
+        verificationIds
       });
       return;
     } catch (error2) {
@@ -8859,7 +8922,8 @@ function useOrgController() {
     getByEmail: _getByEmail,
     getAll: _getAll,
     add: _add,
-    update: _update
+    update: _update,
+    getOrgsByEmail: _getOrgsByEmail
   } = useOrgRepo();
   async function add(req, res, next) {
     const validation = import_joi18.default.object({
@@ -9043,6 +9107,30 @@ function useOrgController() {
       return;
     }
   }
+  async function getOrgsByEmail(req, res, next) {
+    const validation = import_joi18.default.object({
+      email: import_joi18.default.string().email().required()
+    });
+    const query = {
+      email: req.params.email
+    };
+    const { error } = validation.validate(query);
+    if (error) {
+      import_node_server_utils35.logger.log({ level: "error", message: error.message });
+      next(new import_node_server_utils35.BadRequestError(error.message));
+      return;
+    }
+    const email = req.params.email;
+    try {
+      const data = await _getOrgsByEmail(email);
+      res.json(data);
+      return;
+    } catch (error2) {
+      import_node_server_utils35.logger.log({ level: "error", message: error2.message });
+      next(error2);
+      return;
+    }
+  }
   async function update(req, res, next) {
     const validation = import_joi18.default.object({
       name: import_joi18.default.string().optional(),
@@ -9076,7 +9164,8 @@ function useOrgController() {
     getByName,
     getById,
     getByEmail,
-    update
+    update,
+    getOrgsByEmail
   };
 }
 
@@ -12573,6 +12662,33 @@ function useServiceProviderRepo() {
       throw error;
     }
   }
+  async function updateStatusById(_id, status) {
+    try {
+      _id = new import_mongodb34.ObjectId(_id);
+    } catch (error) {
+      throw new import_node_server_utils56.BadRequestError("Invalid service provider ID format.");
+    }
+    try {
+      const result = await collection.updateOne(
+        { _id },
+        { $set: { status, updatedAt: (/* @__PURE__ */ new Date()).toISOString() } }
+      );
+      if (!result.matchedCount) {
+        throw new import_node_server_utils56.NotFoundError("Service provider not found.");
+      }
+      delNamespace().then(() => {
+        import_node_server_utils56.logger.info(`Cache cleared for namespace: ${namespace_collection}`);
+      }).catch((err) => {
+        import_node_server_utils56.logger.error(
+          `Failed to clear cache for namespace: ${namespace_collection}`,
+          err
+        );
+      });
+      return result;
+    } catch (error) {
+      throw error;
+    }
+  }
   return {
     createTextIndex,
     createUniqueIndex,
@@ -12582,7 +12698,8 @@ function useServiceProviderRepo() {
     getServiceProviderTypes,
     getServiceProviderById,
     getByServiceProviderOrgIdType,
-    getByEmail
+    getByEmail,
+    updateStatusById
   };
 }
 
@@ -13358,7 +13475,8 @@ function useServiceProviderController() {
     getServiceProviderTypes: _getServiceProviderTypes,
     getServiceProviderById: _getServiceProviderById,
     getServiceProviders: _getServiceProviders,
-    getByServiceProviderOrgIdType: _getByServiceProviderOrgIdType
+    getByServiceProviderOrgIdType: _getByServiceProviderOrgIdType,
+    updateStatusById: _updateStatusById
   } = useServiceProviderRepo();
   const { createServiceProvider: _createServiceProvider } = useServiceProviderService();
   const { createServiceProvider: _add } = useServiceProviderRepo();
@@ -13572,6 +13690,30 @@ function useServiceProviderController() {
       return;
     }
   }
+  async function updateStatusById(req, res, next) {
+    const validation = import_joi31.default.object({
+      id: import_joi31.default.string().hex().required(),
+      status: import_joi31.default.string().valid("active", "inactive").required()
+    });
+    const { error, value } = validation.validate({
+      id: req.params.id,
+      status: req.body.status
+    });
+    if (error) {
+      import_node_server_utils62.logger.log({ level: "error", message: error.message });
+      next(new import_node_server_utils62.BadRequestError(error.message));
+      return;
+    }
+    try {
+      await _updateStatusById(value.id, value.status);
+      res.json({ message: "Service provider status updated successfully." });
+      return;
+    } catch (error2) {
+      import_node_server_utils62.logger.log({ level: "error", message: error2.message });
+      next(error2);
+      return;
+    }
+  }
   return {
     createServiceProvider,
     getServiceProviders,
@@ -13580,7 +13722,8 @@ function useServiceProviderController() {
     getServiceProviderTypes,
     getServiceProviderById,
     getByServiceProviderOrgIdType,
-    add
+    add,
+    updateStatusById
   };
 }
 
@@ -26604,7 +26747,14 @@ function usePersonService() {
           password: hashedPassword,
           name: value.name,
           status: value.platform == "mobile" ? "pending" : "active",
-          defaultOrg: value.org?.toString() || ""
+          defaultOrg: value.org?.toString() || "",
+          block: value.block,
+          level: value.level,
+          type: value.type,
+          unitName: value.unitName,
+          contact: value.contact,
+          site: value.site?.toString() || "",
+          unitId: value.unit?.toString() || ""
         };
         const userId = await addUser(user, session);
         value.user = userId.toString();
@@ -36250,10 +36400,42 @@ function UseAccessManagementRepo() {
         },
         {
           $facet: {
-            available_physical: [{ $match: { assignedUnit: { $eq: null }, type: "NFC" /* NFC */ } }, { $count: "count" }],
-            available_non_physical: [{ $match: { assignedUnit: { $eq: null }, type: "QRCODE" /* QR */ } }, { $count: "count" }],
-            assigned_physical: [{ $match: { assignedUnit: { $ne: null }, type: "NFC" /* NFC */ } }, { $count: "count" }],
-            assigned_non_physical: [{ $match: { assignedUnit: { $ne: null }, type: "QRCODE" /* QR */ } }, { $count: "count" }]
+            available_physical: [
+              {
+                $match: {
+                  assignedUnit: { $eq: null },
+                  type: "NFC" /* NFC */
+                }
+              },
+              { $count: "count" }
+            ],
+            available_non_physical: [
+              {
+                $match: {
+                  assignedUnit: { $eq: null },
+                  type: "QRCODE" /* QR */
+                }
+              },
+              { $count: "count" }
+            ],
+            assigned_physical: [
+              {
+                $match: {
+                  assignedUnit: { $ne: null },
+                  type: "NFC" /* NFC */
+                }
+              },
+              { $count: "count" }
+            ],
+            assigned_non_physical: [
+              {
+                $match: {
+                  assignedUnit: { $ne: null },
+                  type: "QRCODE" /* QR */
+                }
+              },
+              { $count: "count" }
+            ]
           }
         }
       ]).toArray();
@@ -36338,16 +36520,35 @@ function UseAccessManagementRepo() {
         case terms.length >= 3:
           return {
             $and: [
-              { $expr: { $eq: [{ $toLower: "$name" }, terms[0].toLowerCase()] } },
-              { $expr: { $eq: [{ $toLower: "$level.level" }, terms[1].toLowerCase()] } },
-              { $expr: { $eq: [{ $toLower: "$level.units.name" }, getAfterSecondSlash(search)] } }
+              {
+                $expr: { $eq: [{ $toLower: "$name" }, terms[0].toLowerCase()] }
+              },
+              {
+                $expr: {
+                  $eq: [{ $toLower: "$level.level" }, terms[1].toLowerCase()]
+                }
+              },
+              {
+                $expr: {
+                  $eq: [
+                    { $toLower: "$level.units.name" },
+                    getAfterSecondSlash(search)
+                  ]
+                }
+              }
             ]
           };
         case terms.length === 2:
           return {
             $and: [
-              { $expr: { $eq: [{ $toLower: "$name" }, terms[0].toLowerCase()] } },
-              { $expr: { $eq: [{ $toLower: "$level.level" }, terms[1].toLowerCase()] } }
+              {
+                $expr: { $eq: [{ $toLower: "$name" }, terms[0].toLowerCase()] }
+              },
+              {
+                $expr: {
+                  $eq: [{ $toLower: "$level.level" }, terms[1].toLowerCase()]
+                }
+              }
             ]
           };
         default:
@@ -36375,220 +36576,386 @@ function UseAccessManagementRepo() {
         site
       };
       const searchQuery = buildSearchQuery(search);
-      const result = await collectionName("buildings").aggregate([
-        // ✅ Match early with index-friendly query
-        {
-          $match: {
-            ...defaultQuery,
-            status: { $eq: "active" }
-          }
-        },
-        // ✅ Only project needed fields before heavy lookups
-        {
-          $project: {
-            _id: 1,
-            name: 1,
-            site: 1,
-            block: 1
-          }
-        },
-        // ✅ Use localField/foreignField for better index usage
-        {
-          $lookup: {
-            from: "building-levels",
-            localField: "_id",
-            foreignField: "block",
-            pipeline: [
-              { $match: { status: { $ne: "deleted" } } },
-              {
-                $lookup: {
-                  from: "building-units",
-                  localField: "_id",
-                  foreignField: "level",
-                  pipeline: [
-                    { $match: { status: { $ne: "deleted" }, site } },
-                    { $project: { _id: 1, name: 1 } }
-                  ],
-                  as: "units"
-                }
-              },
-              {
-                $match: { "units.0": { $exists: true } }
-              },
-              {
-                $project: {
-                  _id: 1,
-                  level: 1,
-                  units: 1
+      const result = await collectionName("buildings").aggregate(
+        [
+          // ✅ Match early with index-friendly query
+          {
+            $match: {
+              ...defaultQuery,
+              status: { $eq: "active" }
+            }
+          },
+          // ✅ Only project needed fields before heavy lookups
+          {
+            $project: {
+              _id: 1,
+              name: 1,
+              site: 1,
+              block: 1
+            }
+          },
+          // ✅ Use localField/foreignField for better index usage
+          {
+            $lookup: {
+              from: "building-levels",
+              localField: "_id",
+              foreignField: "block",
+              pipeline: [
+                { $match: { status: { $ne: "deleted" } } },
+                {
+                  $lookup: {
+                    from: "building-units",
+                    localField: "_id",
+                    foreignField: "level",
+                    pipeline: [
+                      { $match: { status: { $ne: "deleted" }, site } },
+                      { $project: { _id: 1, name: 1 } }
+                    ],
+                    as: "units"
+                  }
+                },
+                {
+                  $match: { "units.0": { $exists: true } }
+                },
+                {
+                  $project: {
+                    _id: 1,
+                    level: 1,
+                    units: 1
+                  }
                 }
-              }
-            ],
-            as: "level"
-          }
-        },
-        // ✅ Filter out buildings with no levels early
-        {
-          $match: { "level.0": { $exists: true } }
-        },
-        // ✅ Unwind to flatten the hierarchy
-        {
-          $unwind: {
-            path: "$level",
-            preserveNullAndEmptyArrays: false
-          }
-        },
-        {
-          $unwind: {
-            path: "$level.units",
-            preserveNullAndEmptyArrays: false
-          }
-        },
-        // // Groups by unit _id and keeps only the first occurrence
-        // {
-        //   $group: {
-        //     _id: "$level.units._id",
-        //     doc: { $first: "$$ROOT" },
-        //   },
-        // },
-        // {
-        //   $replaceRoot: { newRoot: "$doc" },
-        // },
-        // ✅ Apply search filter
-        {
-          $match: {
-            ...searchQuery
-          }
-        },
-        {
-          $facet: {
-            totalCount: [{ $count: "count" }],
-            items: [
-              // ✅ Sort BEFORE skip/limit for correct pagination
-              { $skip: page * limit },
-              { $limit: limit },
-              // ✅ Users lookup - optimized with index hint
-              {
-                $lookup: {
-                  from: "users",
-                  let: { unit: "$level.units._id" },
-                  pipeline: [
-                    {
-                      $match: {
-                        $expr: { $eq: ["$unitNumber", "$$unit"] },
-                        residentType: "House/Unit Owner"
+              ],
+              as: "level"
+            }
+          },
+          // ✅ Filter out buildings with no levels early
+          {
+            $match: { "level.0": { $exists: true } }
+          },
+          // ✅ Unwind to flatten the hierarchy
+          {
+            $unwind: {
+              path: "$level",
+              preserveNullAndEmptyArrays: false
+            }
+          },
+          {
+            $unwind: {
+              path: "$level.units",
+              preserveNullAndEmptyArrays: false
+            }
+          },
+          // // Groups by unit _id and keeps only the first occurrence
+          // {
+          //   $group: {
+          //     _id: "$level.units._id",
+          //     doc: { $first: "$$ROOT" },
+          //   },
+          // },
+          // {
+          //   $replaceRoot: { newRoot: "$doc" },
+          // },
+          // ✅ Apply search filter
+          {
+            $match: {
+              ...searchQuery
+            }
+          },
+          {
+            $facet: {
+              totalCount: [{ $count: "count" }],
+              items: [
+                // ✅ Sort BEFORE skip/limit for correct pagination
+                { $skip: page * limit },
+                { $limit: limit },
+                // ✅ Users lookup - optimized with index hint
+                {
+                  $lookup: {
+                    from: "users",
+                    let: { unit: "$level.units._id" },
+                    pipeline: [
+                      {
+                        $match: {
+                          $expr: { $eq: ["$unitNumber", "$$unit"] },
+                          residentType: "House/Unit Owner"
+                        }
+                      },
+                      { $limit: 1 },
+                      { $project: { _id: 1, givenName: 1, surname: 1 } }
+                    ],
+                    as: "unitOwner"
+                  }
+                },
+                // ✅ Access card lookup - optimized query
+                {
+                  $lookup: {
+                    from: "access-cards",
+                    let: { unit: "$level.units._id" },
+                    pipeline: [
+                      {
+                        $match: {
+                          $expr: {
+                            $in: [
+                              "$$unit",
+                              {
+                                $cond: [
+                                  { $isArray: "$assignedUnit" },
+                                  "$assignedUnit",
+                                  ["$assignedUnit"]
+                                ]
+                              }
+                            ]
+                          },
+                          userType
+                        }
+                      },
+                      {
+                        $project: {
+                          _id: 1,
+                          userId: 1,
+                          type: 1,
+                          cardNo: 1,
+                          isActivated: 1,
+                          replacementStatus: 1
+                        }
+                      }
+                    ],
+                    as: "accessCards"
+                  }
+                },
+                // ✅ Compute all card categorization and counts in ONE stage
+                {
+                  $addFields: {
+                    f_Available: {
+                      $filter: {
+                        input: "$accessCards",
+                        as: "card",
+                        cond: {
+                          $and: [
+                            { $eq: ["$$card.userId", null] },
+                            { $eq: ["$$card.isActivated", true] }
+                          ]
+                        }
                       }
                     },
-                    { $limit: 1 },
-                    { $project: { _id: 1, givenName: 1, surname: 1 } }
-                  ],
-                  as: "unitOwner"
-                }
-              },
-              // ✅ Access card lookup - optimized query
-              {
-                $lookup: {
-                  from: "access-cards",
-                  let: { unit: "$level.units._id" },
-                  pipeline: [
-                    {
-                      $match: {
-                        $expr: {
-                          $in: [
-                            "$$unit",
-                            { $cond: [{ $isArray: "$assignedUnit" }, "$assignedUnit", ["$assignedUnit"]] }
+                    f_Assigned: {
+                      $filter: {
+                        input: "$accessCards",
+                        as: "card",
+                        cond: {
+                          $and: [
+                            { $ne: ["$$card.userId", null] },
+                            { $eq: ["$$card.isActivated", true] }
                           ]
-                        },
-                        userType
+                        }
                       }
                     },
-                    { $project: { _id: 1, userId: 1, type: 1, cardNo: 1, isActivated: 1, replacementStatus: 1 } }
-                  ],
-                  as: "accessCards"
-                }
-              },
-              // ✅ Compute all card categorization and counts in ONE stage
-              {
-                $addFields: {
-                  f_Available: {
-                    $filter: {
-                      input: "$accessCards",
-                      as: "card",
-                      cond: { $and: [{ $eq: ["$$card.userId", null] }, { $eq: ["$$card.isActivated", true] }] }
-                    }
-                  },
-                  f_Assigned: {
-                    $filter: {
-                      input: "$accessCards",
-                      as: "card",
-                      cond: { $and: [{ $ne: ["$$card.userId", null] }, { $eq: ["$$card.isActivated", true] }] }
-                    }
-                  },
-                  f_replaced: {
-                    $filter: {
-                      input: "$accessCards",
-                      as: "card",
-                      cond: { $and: [{ $eq: ["$$card.isActivated", false] }, { $ne: ["$$card.replacementStatus", null] }] }
-                    }
-                  },
-                  f_deleted: {
-                    $filter: {
-                      input: "$accessCards",
-                      as: "card",
-                      cond: { $and: [{ $eq: ["$$card.isActivated", false] }, { $eq: ["$$card.replacementStatus", null] }] }
+                    f_replaced: {
+                      $filter: {
+                        input: "$accessCards",
+                        as: "card",
+                        cond: {
+                          $and: [
+                            { $eq: ["$$card.isActivated", false] },
+                            { $ne: ["$$card.replacementStatus", null] }
+                          ]
+                        }
+                      }
+                    },
+                    f_deleted: {
+                      $filter: {
+                        input: "$accessCards",
+                        as: "card",
+                        cond: {
+                          $and: [
+                            { $eq: ["$$card.isActivated", false] },
+                            { $eq: ["$$card.replacementStatus", null] }
+                          ]
+                        }
+                      }
                     }
                   }
-                }
-              },
-              // ✅ Final projection with all computed fields
-              {
-                $project: {
-                  _id: "$level.units._id",
-                  name: "$level.units.name",
-                  level: { _id: "$level._id", level: "$level.level" },
-                  block: { _id: "$_id", name: "$name", block: "$block" },
-                  site: "$site",
-                  unit_owner: { $arrayElemAt: ["$unitOwner", 0] },
-                  available: {
-                    physical: { $filter: { input: "$f_Available", as: "c", cond: { $eq: ["$$c.type", "NFC" /* NFC */] } } },
-                    non_physical: { $filter: { input: "$f_Available", as: "c", cond: { $eq: ["$$c.type", "QRCODE" /* QR */] } } }
-                  },
-                  assigned: {
-                    physical: { $filter: { input: "$f_Assigned", as: "c", cond: { $eq: ["$$c.type", "NFC" /* NFC */] } } },
-                    non_physical: { $filter: { input: "$f_Assigned", as: "c", cond: { $eq: ["$$c.type", "QRCODE" /* QR */] } } }
-                  },
-                  cardCounts: {
+                },
+                // ✅ Final projection with all computed fields
+                {
+                  $project: {
+                    _id: "$level.units._id",
+                    name: "$level.units.name",
+                    level: { _id: "$level._id", level: "$level.level" },
+                    block: { _id: "$_id", name: "$name", block: "$block" },
+                    site: "$site",
+                    unit_owner: { $arrayElemAt: ["$unitOwner", 0] },
                     available: {
-                      physical: { $size: { $filter: { input: { $ifNull: ["$f_Available", []] }, as: "c", cond: { $eq: ["$$c.type", "NFC" /* NFC */] } } } },
-                      non_physical: { $size: { $filter: { input: { $ifNull: ["$f_Available", []] }, as: "c", cond: { $eq: ["$$c.type", "QRCODE" /* QR */] } } } }
+                      physical: {
+                        $filter: {
+                          input: "$f_Available",
+                          as: "c",
+                          cond: { $eq: ["$$c.type", "NFC" /* NFC */] }
+                        }
+                      },
+                      non_physical: {
+                        $filter: {
+                          input: "$f_Available",
+                          as: "c",
+                          cond: { $eq: ["$$c.type", "QRCODE" /* QR */] }
+                        }
+                      }
                     },
                     assigned: {
-                      physical: { $size: { $filter: { input: { $ifNull: ["$f_Assigned", []] }, as: "c", cond: { $eq: ["$$c.type", "NFC" /* NFC */] } } } },
-                      non_physical: { $size: { $filter: { input: { $ifNull: ["$f_Assigned", []] }, as: "c", cond: { $eq: ["$$c.type", "QRCODE" /* QR */] } } } }
+                      physical: {
+                        $filter: {
+                          input: "$f_Assigned",
+                          as: "c",
+                          cond: { $eq: ["$$c.type", "NFC" /* NFC */] }
+                        }
+                      },
+                      non_physical: {
+                        $filter: {
+                          input: "$f_Assigned",
+                          as: "c",
+                          cond: { $eq: ["$$c.type", "QRCODE" /* QR */] }
+                        }
+                      }
+                    },
+                    cardCounts: {
+                      available: {
+                        physical: {
+                          $size: {
+                            $filter: {
+                              input: { $ifNull: ["$f_Available", []] },
+                              as: "c",
+                              cond: {
+                                $eq: ["$$c.type", "NFC" /* NFC */]
+                              }
+                            }
+                          }
+                        },
+                        non_physical: {
+                          $size: {
+                            $filter: {
+                              input: { $ifNull: ["$f_Available", []] },
+                              as: "c",
+                              cond: {
+                                $eq: ["$$c.type", "QRCODE" /* QR */]
+                              }
+                            }
+                          }
+                        }
+                      },
+                      assigned: {
+                        physical: {
+                          $size: {
+                            $filter: {
+                              input: { $ifNull: ["$f_Assigned", []] },
+                              as: "c",
+                              cond: {
+                                $eq: ["$$c.type", "NFC" /* NFC */]
+                              }
+                            }
+                          }
+                        },
+                        non_physical: {
+                          $size: {
+                            $filter: {
+                              input: { $ifNull: ["$f_Assigned", []] },
+                              as: "c",
+                              cond: {
+                                $eq: ["$$c.type", "QRCODE" /* QR */]
+                              }
+                            }
+                          }
+                        }
+                      }
+                    },
+                    replaced: {
+                      physical: {
+                        $filter: {
+                          input: "$f_replaced",
+                          as: "c",
+                          cond: { $eq: ["$$c.type", "NFC" /* NFC */] }
+                        }
+                      },
+                      non_physical: {
+                        $filter: {
+                          input: "$f_replaced",
+                          as: "c",
+                          cond: { $eq: ["$$c.type", "QRCODE" /* QR */] }
+                        }
+                      }
+                    },
+                    deleted: {
+                      physical: {
+                        $filter: {
+                          input: "$f_deleted",
+                          as: "c",
+                          cond: { $eq: ["$$c.type", "NFC" /* NFC */] }
+                        }
+                      },
+                      non_physical: {
+                        $filter: {
+                          input: "$f_deleted",
+                          as: "c",
+                          cond: { $eq: ["$$c.type", "QRCODE" /* QR */] }
+                        }
+                      }
+                    },
+                    totalCardCount: {
+                      $add: [
+                        {
+                          $size: {
+                            $filter: {
+                              input: { $ifNull: ["$f_Available", []] },
+                              as: "c",
+                              cond: {
+                                $eq: ["$$c.type", "NFC" /* NFC */]
+                              }
+                            }
+                          }
+                        },
+                        {
+                          $size: {
+                            $filter: {
+                              input: { $ifNull: ["$f_Available", []] },
+                              as: "c",
+                              cond: {
+                                $eq: ["$$c.type", "QRCODE" /* QR */]
+                              }
+                            }
+                          }
+                        },
+                        {
+                          $size: {
+                            $filter: {
+                              input: { $ifNull: ["$f_Assigned", []] },
+                              as: "c",
+                              cond: {
+                                $eq: ["$$c.type", "NFC" /* NFC */]
+                              }
+                            }
+                          }
+                        },
+                        {
+                          $size: {
+                            $filter: {
+                              input: { $ifNull: ["$f_Assigned", []] },
+                              as: "c",
+                              cond: {
+                                $eq: ["$$c.type", "QRCODE" /* QR */]
+                              }
+                            }
+                          }
+                        }
+                      ]
                     }
-                  },
-                  replaced: {
-                    physical: { $filter: { input: "$f_replaced", as: "c", cond: { $eq: ["$$c.type", "NFC" /* NFC */] } } },
-                    non_physical: { $filter: { input: "$f_replaced", as: "c", cond: { $eq: ["$$c.type", "QRCODE" /* QR */] } } }
-                  },
-                  deleted: {
-                    physical: { $filter: { input: "$f_deleted", as: "c", cond: { $eq: ["$$c.type", "NFC" /* NFC */] } } },
-                    non_physical: { $filter: { input: "$f_deleted", as: "c", cond: { $eq: ["$$c.type", "QRCODE" /* QR */] } } }
-                  },
-                  totalCardCount: {
-                    $add: [
-                      { $size: { $filter: { input: { $ifNull: ["$f_Available", []] }, as: "c", cond: { $eq: ["$$c.type", "NFC" /* NFC */] } } } },
-                      { $size: { $filter: { input: { $ifNull: ["$f_Available", []] }, as: "c", cond: { $eq: ["$$c.type", "QRCODE" /* QR */] } } } },
-                      { $size: { $filter: { input: { $ifNull: ["$f_Assigned", []] }, as: "c", cond: { $eq: ["$$c.type", "NFC" /* NFC */] } } } },
-                      { $size: { $filter: { input: { $ifNull: ["$f_Assigned", []] }, as: "c", cond: { $eq: ["$$c.type", "QRCODE" /* QR */] } } } }
-                    ]
                   }
-                }
-              },
-              { $sort: { totalCardCount: -1 } }
-            ]
+                },
+                { $sort: { totalCardCount: -1 } }
+              ]
+            }
           }
-        }
-      ], { allowDiskUse: true }).toArray();
+        ],
+        { allowDiskUse: true }
+      ).toArray();
       const totalCount = result[0]?.totalCount?.[0]?.count ?? 0;
       const items = result[0]?.items ?? [];
       const paginatedResult = (0, import_node_server_utils154.paginate)(items, page, limit, totalCount);
@@ -36607,157 +36974,162 @@ function UseAccessManagementRepo() {
         site: { $in: [site] }
       };
       const searchQuery = buildSearchQuery(search);
-      const result = await collectionName("buildings").aggregate([
-        // ✅ Match early with index-friendly query
-        {
-          $match: {
-            ...query,
-            status: { $ne: "deleted" }
-          }
-        },
-        // ✅ Only project needed fields before heavy lookups
-        {
-          $project: {
-            _id: 1,
-            name: 1,
-            site: 1
-          }
-        },
-        // ✅ Use localField/foreignField for better index usage
-        {
-          $lookup: {
-            from: "building-levels",
-            localField: "_id",
-            foreignField: "block",
-            pipeline: [
-              { $match: { status: { $ne: "deleted" } } },
-              {
-                $lookup: {
-                  from: "building-units",
-                  localField: "_id",
-                  foreignField: "level",
-                  pipeline: [
-                    { $match: { status: { $ne: "deleted" } } },
-                    { $project: { _id: 1, name: 1 } },
-                    {
-                      $lookup: {
-                        from: "access-cards",
-                        localField: "_id",
-                        foreignField: "assignedUnit",
-                        pipeline: [
-                          {
-                            $match: {
-                              isActivated: true,
-                              userType,
-                              type
-                            }
-                          },
-                          {
-                            $group: {
-                              _id: null,
-                              accessLevels: { $addToSet: "$accessLevel" },
-                              liftAccessLevels: { $addToSet: "$liftAccessLevel" },
-                              doorNames: { $addToSet: "$doorName" },
-                              liftNames: { $addToSet: "$liftName" },
-                              cards: {
-                                $push: {
-                                  _id: "$_id",
-                                  cardNo: "$cardNo",
-                                  accessLevel: "$accessLevel",
-                                  liftAccessLevel: "$liftAccessLevel",
-                                  doorName: "$doorName",
-                                  liftName: "$liftName"
+      const result = await collectionName("buildings").aggregate(
+        [
+          // ✅ Match early with index-friendly query
+          {
+            $match: {
+              ...query,
+              status: { $ne: "deleted" }
+            }
+          },
+          // ✅ Only project needed fields before heavy lookups
+          {
+            $project: {
+              _id: 1,
+              name: 1,
+              site: 1
+            }
+          },
+          // ✅ Use localField/foreignField for better index usage
+          {
+            $lookup: {
+              from: "building-levels",
+              localField: "_id",
+              foreignField: "block",
+              pipeline: [
+                { $match: { status: { $ne: "deleted" } } },
+                {
+                  $lookup: {
+                    from: "building-units",
+                    localField: "_id",
+                    foreignField: "level",
+                    pipeline: [
+                      { $match: { status: { $ne: "deleted" } } },
+                      { $project: { _id: 1, name: 1 } },
+                      {
+                        $lookup: {
+                          from: "access-cards",
+                          localField: "_id",
+                          foreignField: "assignedUnit",
+                          pipeline: [
+                            {
+                              $match: {
+                                isActivated: true,
+                                userType,
+                                type
+                              }
+                            },
+                            {
+                              $group: {
+                                _id: null,
+                                accessLevels: { $addToSet: "$accessLevel" },
+                                liftAccessLevels: {
+                                  $addToSet: "$liftAccessLevel"
+                                },
+                                doorNames: { $addToSet: "$doorName" },
+                                liftNames: { $addToSet: "$liftName" },
+                                cards: {
+                                  $push: {
+                                    _id: "$_id",
+                                    cardNo: "$cardNo",
+                                    accessLevel: "$accessLevel",
+                                    liftAccessLevel: "$liftAccessLevel",
+                                    doorName: "$doorName",
+                                    liftName: "$liftName"
+                                  }
                                 }
                               }
+                            },
+                            {
+                              $project: {
+                                _id: 0,
+                                accessCardCount: {
+                                  $size: "$cards"
+                                },
+                                accessLevels: 1,
+                                liftAccessLevels: 1,
+                                doorNames: 1,
+                                liftNames: 1
+                              }
                             }
-                          },
-                          {
-                            $project: {
-                              _id: 0,
-                              accessCardCount: {
-                                $size: "$cards"
-                              },
-                              accessLevels: 1,
-                              liftAccessLevels: 1,
-                              doorNames: 1,
-                              liftNames: 1
-                            }
-                          }
-                        ],
-                        as: "fAccessCards"
-                      }
-                    },
-                    {
-                      $match: {
-                        "fAccessCards.0": { $exists: true }
+                          ],
+                          as: "fAccessCards"
+                        }
+                      },
+                      {
+                        $match: {
+                          "fAccessCards.0": { $exists: true }
+                        }
                       }
-                    }
-                  ],
-                  as: "units"
-                }
-              },
-              {
-                $match: { "units.0": { $exists: true } }
-              },
-              {
-                $project: {
-                  _id: 1,
-                  level: 1,
-                  units: 1
+                    ],
+                    as: "units"
+                  }
+                },
+                {
+                  $match: { "units.0": { $exists: true } }
+                },
+                {
+                  $project: {
+                    _id: 1,
+                    level: 1,
+                    units: 1
+                  }
                 }
-              }
-            ],
-            as: "level"
-          }
-        },
-        // ✅ Filter out buildings with no levels early
-        {
-          $match: { "level.0": { $exists: true } }
-        },
-        // ✅ Unwind to flatten the hierarchy
-        {
-          $unwind: {
-            path: "$level",
-            preserveNullAndEmptyArrays: false
-          }
-        },
-        {
-          $unwind: {
-            path: "$level.units",
-            preserveNullAndEmptyArrays: false
-          }
-        },
-        {
-          $unwind: {
-            path: "$level.units.fAccessCards",
-            preserveNullAndEmptyArrays: false
-          }
-        },
-        // // Groups by unit _id and keeps only the first occurrence
-        {
-          $group: {
-            _id: "$level.units._id",
-            doc: { $first: "$$ROOT" }
-          }
-        },
-        {
-          $replaceRoot: { newRoot: "$doc" }
-        },
-        // ✅ Apply search filter
-        {
-          $match: {
-            ...searchQuery
-          }
-        },
-        {
-          $project: {
-            name: 1,
-            "level.level": 1,
-            "level.units.name": 1,
-            "level.units.fAccessCards": 1
+              ],
+              as: "level"
+            }
+          },
+          // ✅ Filter out buildings with no levels early
+          {
+            $match: { "level.0": { $exists: true } }
+          },
+          // ✅ Unwind to flatten the hierarchy
+          {
+            $unwind: {
+              path: "$level",
+              preserveNullAndEmptyArrays: false
+            }
+          },
+          {
+            $unwind: {
+              path: "$level.units",
+              preserveNullAndEmptyArrays: false
+            }
+          },
+          {
+            $unwind: {
+              path: "$level.units.fAccessCards",
+              preserveNullAndEmptyArrays: false
+            }
+          },
+          // // Groups by unit _id and keeps only the first occurrence
+          {
+            $group: {
+              _id: "$level.units._id",
+              doc: { $first: "$$ROOT" }
+            }
+          },
+          {
+            $replaceRoot: { newRoot: "$doc" }
+          },
+          // ✅ Apply search filter
+          {
+            $match: {
+              ...searchQuery
+            }
+          },
+          {
+            $project: {
+              name: 1,
+              "level.level": 1,
+              "level.units.name": 1,
+              "level.units.fAccessCards": 1
+            }
           }
-        }
-      ], { allowDiskUse: true }).toArray();
+        ],
+        { allowDiskUse: true }
+      ).toArray();
       return result;
     } catch (error) {
       throw new Error(error.message);
@@ -36768,8 +37140,12 @@ function UseAccessManagementRepo() {
     try {
       session?.startTransaction();
       const { userId, cardId, site } = params;
-      const allUserId = await Promise.all(userId.map(async (id) => new import_mongodb90.ObjectId(id)));
-      const allCardId = await Promise.all(cardId.map(async (id) => new import_mongodb90.ObjectId(id)));
+      const allUserId = await Promise.all(
+        userId.map(async (id) => new import_mongodb90.ObjectId(id))
+      );
+      const allCardId = await Promise.all(
+        cardId.map(async (id) => new import_mongodb90.ObjectId(id))
+      );
       const siteId = new import_mongodb90.ObjectId(site);
       const result = await collection().updateMany(
         {
@@ -36812,16 +37188,19 @@ function UseAccessManagementRepo() {
         liftAccessLevel,
         isActivated: true
       };
-      const result = await collection().aggregate([
-        {
-          $match: query
-        },
-        {
-          $facet: {
-            counts: [{ $count: "count" }]
+      const result = await collection().aggregate(
+        [
+          {
+            $match: query
+          },
+          {
+            $facet: {
+              counts: [{ $count: "count" }]
+            }
           }
-        }
-      ], { allowDiskUse: true }).toArray();
+        ],
+        { allowDiskUse: true }
+      ).toArray();
       return result;
     } catch (error) {
       throw new Error(error.message);
@@ -36855,7 +37234,9 @@ function UseAccessManagementRepo() {
         availableCardNo.push(num);
         num++;
       }
-      const cardNumbers = availableCardNo.map((no) => no.toString().padStart(10, "0"));
+      const cardNumbers = availableCardNo.map(
+        (no) => no.toString().padStart(10, "0")
+      );
       const accessCards = [];
       const convertedUnits = unit.map((obj) => new import_mongodb90.ObjectId(obj));
       for (let j = 0; j < (unit.length > 0 ? unit.length : quantity); j++) {
@@ -36915,10 +37296,18 @@ function UseAccessManagementRepo() {
           liftAccessEndDate: formatEntryPassDate(item.liftAccessEndDate) || "19770510",
           accessGroup: ag
         };
-        return readTemplate(`${item.accessLevel !== null ? "add-card" : "add-card-lift"}`, { ...command });
+        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_xml2js2.parseStringPromise)(response, { explicitArray: false });
+      const response = await sendCommand(
+        commands.join("").toString(),
+        params.acm_url
+      );
+      const result = await (0, import_xml2js2.parseStringPromise)(response, {
+        explicitArray: false
+      });
       if (result && result.RESULT.$.STCODE !== "0") {
         throw new Error("Command failed, server error.");
       }
@@ -36952,7 +37341,11 @@ function UseAccessManagementRepo() {
           } else {
             updateFields.isActivated = true;
           }
-          const res = await collection().updateOne({ _id: card._id }, { $set: updateFields }, { session });
+          const res = await collection().updateOne(
+            { _id: card._id },
+            { $set: updateFields },
+            { session }
+          );
           results.push({ nfcId: nfc._id, modifiedCount: res.modifiedCount });
         }
       }
@@ -36979,8 +37372,20 @@ function UseAccessManagementRepo() {
             assignedUnit: null,
             userId: null,
             $or: [
-              { $and: [{ doorName: { $ne: null } }, { doorName: { $ne: "" } }, { accessLevel: { $ne: null } }] },
-              { $and: [{ liftName: { $ne: null } }, { liftName: { $ne: "" } }, { liftAccessLevel: { $ne: null } }] }
+              {
+                $and: [
+                  { doorName: { $ne: null } },
+                  { doorName: { $ne: "" } },
+                  { accessLevel: { $ne: null } }
+                ]
+              },
+              {
+                $and: [
+                  { liftName: { $ne: null } },
+                  { liftName: { $ne: "" } },
+                  { liftAccessLevel: { $ne: null } }
+                ]
+              }
             ]
           }
         },
@@ -36994,7 +37399,13 @@ function UseAccessManagementRepo() {
                   accessLevels: {
                     $addToSet: {
                       $cond: [
-                        { $and: [{ $ne: ["$doorName", null] }, { $ne: ["$doorName", ""] }, { $ne: ["$accessLevel", null] }] },
+                        {
+                          $and: [
+                            { $ne: ["$doorName", null] },
+                            { $ne: ["$doorName", ""] },
+                            { $ne: ["$accessLevel", null] }
+                          ]
+                        },
                         { name: "$doorName", no: "$accessLevel" },
                         "$$REMOVE"
                       ]
@@ -37003,7 +37414,13 @@ function UseAccessManagementRepo() {
                   liftAccessLevels: {
                     $addToSet: {
                       $cond: [
-                        { $and: [{ $ne: ["$liftName", null] }, { $ne: ["$liftName", ""] }, { $ne: ["$liftAccessLevel", null] }] },
+                        {
+                          $and: [
+                            { $ne: ["$liftName", null] },
+                            { $ne: ["$liftName", ""] },
+                            { $ne: ["$liftAccessLevel", null] }
+                          ]
+                        },
                         { name: "$liftName", no: "$liftAccessLevel" },
                         "$$REMOVE"
                       ]
@@ -37039,7 +37456,14 @@ function UseAccessManagementRepo() {
       const sessionResult = await Promise.all([
         await collection().findOneAndUpdate(
           { _id: id },
-          { $set: { remarks, replacementStatus: "Complete", requestDate: /* @__PURE__ */ new Date(), isActivated: false } },
+          {
+            $set: {
+              remarks,
+              replacementStatus: "Complete",
+              requestDate: /* @__PURE__ */ new Date(),
+              isActivated: false
+            }
+          },
           { returnDocument: "after", session }
         ),
         await collection().findOneAndUpdate(
@@ -37071,7 +37495,10 @@ function UseAccessManagementRepo() {
         isActivated: true
       };
       if (search) {
-        query.$or = [{ accessLevel: { $regex: search, $options: "i" } }, { cardNo: { $regex: search, $options: "i" } }];
+        query.$or = [
+          { accessLevel: { $regex: search, $options: "i" } },
+          { cardNo: { $regex: search, $options: "i" } }
+        ];
       }
       if (type) {
         query.userType = type;
@@ -37096,14 +37523,22 @@ function UseAccessManagementRepo() {
         {
           $addFields: {
             extractedCardNo: {
-              $substr: ["$cardNo", { $subtract: [{ $strLenCP: "$cardNo" }, 5] }, 5]
+              $substr: [
+                "$cardNo",
+                { $subtract: [{ $strLenCP: "$cardNo" }, 5] },
+                5
+              ]
             }
           }
         },
         {
           $facet: {
             totalCount: [{ $count: "count" }],
-            items: [{ $sort: { _id: -1 } }, { $skip: page * limit }, { $limit: limit }]
+            items: [
+              { $sort: { _id: -1 } },
+              { $skip: page * limit },
+              { $limit: limit }
+            ]
           }
         }
       ]).toArray();
@@ -37134,145 +37569,151 @@ function UseAccessManagementRepo() {
         query.replacementStatus = statusFilter;
       }
       if (dateFrom && dateTo) {
-        query.requestDate = { $gte: new Date(dateFrom), $lte: new Date(dateTo) };
+        query.requestDate = {
+          $gte: new Date(dateFrom),
+          $lte: new Date(dateTo)
+        };
       } else if (dateFrom) {
         query.requestDate = { $gte: new Date(dateFrom) };
       } else if (dateTo) {
         query.requestDate = { $lte: new Date(dateTo) };
       }
-      const res = await collection().aggregate([
-        {
-          $match: { ...query }
-        },
-        {
-          $lookup: {
-            from: "building-units",
-            let: { unit: "$assignedUnit" },
-            pipeline: [
-              {
-                $match: {
-                  $expr: {
-                    $eq: ["$_id", "$$unit"]
+      const res = await collection().aggregate(
+        [
+          {
+            $match: { ...query }
+          },
+          {
+            $lookup: {
+              from: "building-units",
+              let: { unit: "$assignedUnit" },
+              pipeline: [
+                {
+                  $match: {
+                    $expr: {
+                      $eq: ["$_id", "$$unit"]
+                    }
                   }
-                }
-              },
-              {
-                $project: {
-                  _id: 1,
-                  name: 1,
-                  level: 1
-                }
-              }
-            ],
-            as: "unit"
-          }
-        },
-        {
-          $unwind: { path: "$unit", preserveNullAndEmptyArrays: true }
-        },
-        {
-          $lookup: {
-            from: "building-levels",
-            let: { level: "$unit.level" },
-            pipeline: [
-              {
-                $match: {
-                  $expr: {
-                    $eq: ["$_id", "$$level"]
+                },
+                {
+                  $project: {
+                    _id: 1,
+                    name: 1,
+                    level: 1
                   }
                 }
-              },
-              {
-                $project: {
-                  _id: 1,
-                  level: 1,
-                  block: 1
-                }
-              }
-            ],
-            as: "level"
-          }
-        },
-        {
-          $unwind: { path: "$level", preserveNullAndEmptyArrays: true }
-        },
-        {
-          $lookup: {
-            from: "buildings",
-            let: { block: "$level.block" },
-            pipeline: [
-              {
-                $match: {
-                  $expr: {
-                    $eq: ["$_id", "$$block"]
+              ],
+              as: "unit"
+            }
+          },
+          {
+            $unwind: { path: "$unit", preserveNullAndEmptyArrays: true }
+          },
+          {
+            $lookup: {
+              from: "building-levels",
+              let: { level: "$unit.level" },
+              pipeline: [
+                {
+                  $match: {
+                    $expr: {
+                      $eq: ["$_id", "$$level"]
+                    }
+                  }
+                },
+                {
+                  $project: {
+                    _id: 1,
+                    level: 1,
+                    block: 1
                   }
                 }
-              },
-              {
-                $project: {
-                  _id: 1,
-                  name: 1
-                }
-              }
-            ],
-            as: "building"
-          }
-        },
-        {
-          $unwind: { path: "$building", preserveNullAndEmptyArrays: true }
-        },
-        {
-          $lookup: {
-            from: "users",
-            let: { id: "$userId" },
-            pipeline: [
-              {
-                $match: {
-                  $expr: {
-                    $eq: ["$_id", "$$id"]
+              ],
+              as: "level"
+            }
+          },
+          {
+            $unwind: { path: "$level", preserveNullAndEmptyArrays: true }
+          },
+          {
+            $lookup: {
+              from: "buildings",
+              let: { block: "$level.block" },
+              pipeline: [
+                {
+                  $match: {
+                    $expr: {
+                      $eq: ["$_id", "$$block"]
+                    }
+                  }
+                },
+                {
+                  $project: {
+                    _id: 1,
+                    name: 1
                   }
                 }
-              },
-              {
-                $project: {
-                  givenName: 1,
-                  surname: 1
+              ],
+              as: "building"
+            }
+          },
+          {
+            $unwind: { path: "$building", preserveNullAndEmptyArrays: true }
+          },
+          {
+            $lookup: {
+              from: "users",
+              let: { id: "$userId" },
+              pipeline: [
+                {
+                  $match: {
+                    $expr: {
+                      $eq: ["$_id", "$$id"]
+                    }
+                  }
+                },
+                {
+                  $project: {
+                    givenName: 1,
+                    surname: 1
+                  }
                 }
-              }
-            ],
-            as: "user"
-          }
-        },
-        {
-          $unwind: { path: "$user", preserveNullAndEmptyArrays: true }
-        },
-        {
-          $match: { ...searchQuery }
-        },
-        {
-          $facet: {
-            data: [
-              { $skip: page * limit },
-              { $limit: limit },
-              {
-                $project: {
-                  _id: 1,
-                  cardNo: 1,
-                  accessLevel: 1,
-                  liftAccessLevel: 1,
-                  replacementStatus: 1,
-                  remarks: 1,
-                  block: "$building.name",
-                  level: "$level.level",
-                  unit: "$unit.name",
-                  user: "$user"
+              ],
+              as: "user"
+            }
+          },
+          {
+            $unwind: { path: "$user", preserveNullAndEmptyArrays: true }
+          },
+          {
+            $match: { ...searchQuery }
+          },
+          {
+            $facet: {
+              data: [
+                { $skip: page * limit },
+                { $limit: limit },
+                {
+                  $project: {
+                    _id: 1,
+                    cardNo: 1,
+                    accessLevel: 1,
+                    liftAccessLevel: 1,
+                    replacementStatus: 1,
+                    remarks: 1,
+                    block: "$building.name",
+                    level: "$level.level",
+                    unit: "$unit.name",
+                    user: "$user"
+                  }
                 }
-              }
-            ],
-            totalCount: [{ $count: "count" }]
+              ],
+              totalCount: [{ $count: "count" }]
+            }
           }
-        }
-      ], { allowDiskUse: true }).toArray();
+        ],
+        { allowDiskUse: true }
+      ).toArray();
       const count = res[0]?.totalCount[0] ? res[0].totalCount[0].count : 0;
       const pagination = (0, import_node_server_utils154.paginate)(res[0].data, page, limit, count);
       return pagination;
@@ -37284,7 +37725,10 @@ function UseAccessManagementRepo() {
     try {
       const { site } = params;
       const siteId = new import_mongodb90.ObjectId(site);
-      const res = await collectionName("entrypass-settings").findOne({ site: siteId }, { allowDiskUse: true });
+      const res = await collectionName("entrypass-settings").findOne(
+        { site: siteId },
+        { allowDiskUse: true }
+      );
       return res;
     } catch (error) {
       throw new Error(error.message);
@@ -37294,13 +37738,19 @@ function UseAccessManagementRepo() {
     const session = import_node_server_utils154.useAtlas.getClient()?.startSession();
     try {
       const { dataJson, site } = params;
-      const rawItems = JSON.parse(dataJson).filter((_, index) => index !== -1);
+      const rawItems = JSON.parse(dataJson).filter(
+        (_, index) => index !== -1
+      );
       const items = await Promise.all(
         rawItems.map(async (item) => {
           const date = new Date(item["startDate (format MM/DD/YYYY)"]);
           const endDate = new Date(date.setFullYear(date.getFullYear() + 10));
-          const cardNumber = String(Number(item["cardNo (number 0-65535 ex. 301)"] || 0)).padStart(6, "0");
-          const facilityCode = String(Number(item["facilityCode (number 0-255 ex. 11)"] || 0)).padStart(4, "0");
+          const cardNumber = String(
+            Number(item["cardNo (number 0-65535 ex. 301)"] || 0)
+          ).padStart(6, "0");
+          const facilityCode = String(
+            Number(item["facilityCode (number 0-255 ex. 11)"] || 0)
+          ).padStart(4, "0");
           const pin = item["pin (number 6 digits only)"] ? item["pin (number 6 digits only)"].toString().padStart(6, "0") : "123456";
           const match = item["accessLevel (number ex. 1)"];
           const accessLevel = match ? match : null;
@@ -37331,7 +37781,10 @@ function UseAccessManagementRepo() {
           });
         })
       );
-      const result = await collection().insertMany(items, { session, ordered: false });
+      const result = await collection().insertMany(items, {
+        session,
+        ordered: false
+      });
       const mapping = items.map((item, i) => ({
         cardNo: item.cardNo,
         insertedId: result.insertedIds[i]
@@ -37346,8 +37799,19 @@ function UseAccessManagementRepo() {
     let isAborted = false;
     try {
       await session?.startTransaction();
-      const { units, quantity, type, site, userType, accessLevel, liftAccessLevel } = params;
-      const [convertedUnits, convertedSite] = await Promise.all([Promise.all(units.map((id) => new import_mongodb90.ObjectId(id))), new import_mongodb90.ObjectId(site)]);
+      const {
+        units,
+        quantity,
+        type,
+        site,
+        userType,
+        accessLevel,
+        liftAccessLevel
+      } = params;
+      const [convertedUnits, convertedSite] = await Promise.all([
+        Promise.all(units.map((id) => new import_mongodb90.ObjectId(id))),
+        new import_mongodb90.ObjectId(site)
+      ]);
       const totalRequired = quantity * convertedUnits.length;
       const availableCards = await collection().find({
         assignedUnit: null,
@@ -37367,16 +37831,18 @@ function UseAccessManagementRepo() {
           message: `Insufficient ${type} access cards. Need ${totalRequired}, but only ${availableCards.length} available.`
         };
       }
-      const bulkUpdates = availableCards.map((card, index) => ({
-        updateOne: {
-          filter: { _id: card._id },
-          update: {
-            $set: {
-              assignedUnit: convertedUnits[Math.floor(index / quantity)]
+      const bulkUpdates = availableCards.map(
+        (card, index) => ({
+          updateOne: {
+            filter: { _id: card._id },
+            update: {
+              $set: {
+                assignedUnit: convertedUnits[Math.floor(index / quantity)]
+              }
             }
           }
-        }
-      }));
+        })
+      );
       await collection().bulkWrite(bulkUpdates, { session });
       await session?.commitTransaction();
       return {
@@ -37397,7 +37863,18 @@ function UseAccessManagementRepo() {
     try {
       const { cardId, remarks } = params;
       const id = new import_mongodb90.ObjectId(cardId);
-      const result = await collection().findOneAndUpdate({ _id: id }, { $set: { isActivated: false, updatedAt: /* @__PURE__ */ new Date(), remarks, requestDate: /* @__PURE__ */ new Date() } }, { returnDocument: "after" });
+      const result = await collection().findOneAndUpdate(
+        { _id: id },
+        {
+          $set: {
+            isActivated: false,
+            updatedAt: /* @__PURE__ */ new Date(),
+            remarks,
+            requestDate: /* @__PURE__ */ new Date()
+          }
+        },
+        { returnDocument: "after" }
+      );
       return result;
     } catch (error) {
       throw new Error(error.message);
@@ -37458,7 +37935,13 @@ function UseAccessManagementRepo() {
       const { site, payload } = params;
       const id = new import_mongodb90.ObjectId(site);
       const highestCardNo = await collection().aggregate([
-        { $match: { site: id, type: "NFC" /* NFC */, userType: "Visitor/Resident" /* DEFAULT */ } },
+        {
+          $match: {
+            site: id,
+            type: "NFC" /* NFC */,
+            userType: "Visitor/Resident" /* DEFAULT */
+          }
+        },
         {
           $addFields: {
             qrTagCardNoNumeric: { $toInt: "$qrTagCardNo" }
@@ -37478,14 +37961,19 @@ function UseAccessManagementRepo() {
       if (highestCardNo.length > 0) {
         start = highestCardNo[0].qrTagCardNoNumeric || 0;
       }
-      const nextCardNumbers = Array.from({ length: payload.length }, (_, i) => String(start + i + 1).padStart(5, "0"));
+      const nextCardNumbers = Array.from(
+        { length: payload.length },
+        (_, i) => String(start + i + 1).padStart(5, "0")
+      );
       const bulkOps = await Promise.all(
         payload.map(async (doc, index) => {
           const id2 = new import_mongodb90.ObjectId(doc._id);
           return {
             updateOne: {
               filter: { _id: id2 },
-              update: { $set: { qrTag: doc.qrTag, qrTagCardNo: nextCardNumbers[index] } }
+              update: {
+                $set: { qrTag: doc.qrTag, qrTagCardNo: nextCardNumbers[index] }
+              }
             }
           };
         })
@@ -37527,7 +38015,11 @@ function UseAccessManagementRepo() {
         {
           $addFields: {
             extractedCardNo: {
-              $substr: ["$cardNo", { $subtract: [{ $strLenCP: "$cardNo" }, 5] }, 5]
+              $substr: [
+                "$cardNo",
+                { $subtract: [{ $strLenCP: "$cardNo" }, 5] },
+                5
+              ]
             }
           }
         },
@@ -37565,7 +38057,11 @@ function UseAccessManagementRepo() {
         },
         {
           $facet: {
-            items: [{ $skip: page * limit }, { $limit: limit }, { $project: { cardNo: 1 } }],
+            items: [
+              { $skip: page * limit },
+              { $limit: limit },
+              { $project: { cardNo: 1 } }
+            ],
             totalCounts: [{ $count: "count" }]
           }
         }
@@ -37576,7 +38072,9 @@ function UseAccessManagementRepo() {
             _id: unitId
           }
         },
-        { $project: { _id: 1, name: 1, buildingName: 1, block: 1, level: 1 } },
+        {
+          $project: { _id: 1, name: 1, buildingName: 1, block: 1, level: 1 }
+        },
         {
           $lookup: {
             from: "building-levels",
@@ -37664,7 +38162,18 @@ function UseAccessManagementRepo() {
             items: [
               { $skip: 0 },
               { $limit: 1 },
-              { $project: { _id: -1, accessLevel: 1, accessGroup: 1, userType: 1, doorName: 1, liftName: 1, liftAccessLevel: 1, isLiftCard: 1 } }
+              {
+                $project: {
+                  _id: -1,
+                  accessLevel: 1,
+                  accessGroup: 1,
+                  userType: 1,
+                  doorName: 1,
+                  liftName: 1,
+                  liftAccessLevel: 1,
+                  isLiftCard: 1
+                }
+              }
             ]
           }
         }
@@ -37713,13 +38222,25 @@ function UseAccessManagementRepo() {
         cardsToAttach = [...cardsId];
       } else if (type === "NFC" /* NFC */) {
         if (nfcCards && nfcCards.length > 0) {
-          const objectIds = nfcCards.map((card) => new import_mongodb90.ObjectId(card._id));
+          const objectIds = nfcCards.map(
+            (card) => new import_mongodb90.ObjectId(card._id)
+          );
           cards = await collection().find({ _id: { $in: objectIds } }).toArray();
-          const nfcList = objectIds.map((card) => ({ _id: card, status: "In use", updatedAt: /* @__PURE__ */ new Date() }));
+          const nfcList = objectIds.map((card) => ({
+            _id: card,
+            status: "In use",
+            updatedAt: /* @__PURE__ */ new Date()
+          }));
           cardsToAttach = [...nfcList];
         }
       }
-      const result = await collectionName("visitor.transactions").findOneAndUpdate({ _id: visitorId }, { $push: { cards: cardsToAttach } }, { session, returnDocument: "after" });
+      const result = await collectionName(
+        "visitor.transactions"
+      ).findOneAndUpdate(
+        { _id: visitorId },
+        { $push: { cards: cardsToAttach } },
+        { session, returnDocument: "after" }
+      );
       const updatedVisitor = result?._id;
       const assignCards = cards.map((card) => card._id);
       if (assignCards.length > 0) {
@@ -37775,10 +38296,18 @@ function UseAccessManagementRepo() {
             liftAccessEndDate: formatEntryPassDate(item.liftAccessEndDate) || "19770510",
             accessGroup: ag
           };
-          return readTemplate(`${item.accessLevel !== null ? "add-card" : "add-card-lift"}`, { ...command });
+          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_xml2js2.parseStringPromise)(response, { explicitArray: false });
+        const response = await sendCommand(
+          commands.join("").toString(),
+          acm_url
+        );
+        serverResult = await (0, import_xml2js2.parseStringPromise)(response, {
+          explicitArray: false
+        });
         if (result && serverResult.RESULT.$.STCODE !== "0") {
           throw new Error("Command failed, server error.");
         }
@@ -37827,7 +38356,10 @@ function UseAccessManagementRepo() {
     try {
       await session?.startTransaction();
       const userId = new import_mongodb90.ObjectId(params.userId);
-      const result = await collection().updateMany({ userId }, { $set: { userId: null, status: "Available", updatedAt: /* @__PURE__ */ new Date() } });
+      const result = await collection().updateMany(
+        { userId },
+        { $set: { userId: null, status: "Available", updatedAt: /* @__PURE__ */ new Date() } }
+      );
       await session?.commitTransaction();
       return result;
     } catch (error) {
@@ -37871,7 +38403,15 @@ function UseAccessManagementRepo() {
                   foreignField: "level",
                   pipeline: [
                     { $match: { status: { $ne: "deleted" } } },
-                    { $project: { _id: 1, name: 1, buildingName: 1, level: 1, block: 1 } }
+                    {
+                      $project: {
+                        _id: 1,
+                        name: 1,
+                        buildingName: 1,
+                        level: 1,
+                        block: 1
+                      }
+                    }
                   ],
                   as: "units"
                 }
@@ -37892,11 +38432,20 @@ function UseAccessManagementRepo() {
       throw new Error(error.message);
     }
   }
-  async function getTransactionsRepo({ page = 1, limit = 10, site, cardNo, url }) {
+  async function getTransactionsRepo({
+    page = 1,
+    limit = 10,
+    site,
+    cardNo,
+    url
+  }) {
     page = page ? page - 1 : 0;
     site = new import_mongodb90.ObjectId(site);
     try {
-      let index = await collectionName("access-card-transactions").findOne({}, { sort: { index: -1 } });
+      let index = await collectionName("access-card-transactions").findOne(
+        {},
+        { sort: { index: -1 } }
+      );
       index = index ? index.index : 0;
       const response = await getTransactions(index, url);
       if (response && Array.isArray(response.items) && response.items.length > 0) {
@@ -37905,7 +38454,9 @@ function UseAccessManagementRepo() {
           data: JSON.parse(item.data),
           timestamp: item.timestamp
         }));
-        result2 = result2.filter((item) => item.data.Event.ETYPE === "0" && item.data.Event.CARDNO !== "");
+        result2 = result2.filter(
+          (item) => item.data.Event.ETYPE === "0" && item.data.Event.CARDNO !== ""
+        );
         if (result2.length > 0) {
           const transactions = result2.map(
             (item) => new MAccessCardTransaction({
@@ -37916,11 +38467,16 @@ function UseAccessManagementRepo() {
               accessType: item.data.Event.DEVNAME,
               accessStatus: item.data.Event.TRCODE,
               description: item.data.Event.TRDESC,
-              accessTime: entryPassDate(item.data.Event.TRDATE, item.data.Event.TRTIME),
+              accessTime: entryPassDate(
+                item.data.Event.TRDATE,
+                item.data.Event.TRTIME
+              ),
               createdAt: /* @__PURE__ */ new Date()
             })
           );
-          await collectionName("access-card-transactions").insertMany(transactions);
+          await collectionName("access-card-transactions").insertMany(
+            transactions
+          );
         }
       }
       const result = await collectionName("access-card-transactions").aggregate([
@@ -37991,7 +38547,11 @@ function UseAccessManagementRepo() {
         {
           $facet: {
             totalCount: [{ $count: "count" }],
-            items: [{ $sort: { _id: -1 } }, { $skip: page * limit }, { $limit: limit }]
+            items: [
+              { $sort: { _id: -1 } },
+              { $skip: page * limit },
+              { $limit: limit }
+            ]
           }
         }
       ]).toArray();
@@ -38014,7 +38574,9 @@ function UseAccessManagementRepo() {
       if (assignees.length < 1) {
         throw new Error("No user to Assign.");
       }
-      assignees = assignees.map((data) => new import_mongodb90.ObjectId(data));
+      assignees = assignees.map(
+        (data) => new import_mongodb90.ObjectId(data)
+      );
       unit = new import_mongodb90.ObjectId(unit);
       let availableCards = [];
       let update = [];
@@ -38024,7 +38586,18 @@ function UseAccessManagementRepo() {
           $match: {
             $expr: {
               $and: [
-                { $eq: ["$assignedUnit", unit] },
+                {
+                  $in: [
+                    unit,
+                    {
+                      $cond: [
+                        { $isArray: "$assignedUnit" },
+                        "$assignedUnit",
+                        ["$assignedUnit"]
+                      ]
+                    }
+                  ]
+                },
                 { $eq: ["$userId", null] },
                 { $eq: ["$type", type] },
                 { $eq: ["$isActivated", true] }
@@ -38041,7 +38614,10 @@ function UseAccessManagementRepo() {
         card.staffNo = userId.toString().slice(-10);
         return card;
       });
-      update = availableCards.slice(0, assignees.length).map((card, index) => ({ _id: card._id, userId: new import_mongodb90.ObjectId(assignees[index]) }));
+      update = availableCards.slice(0, assignees.length).map((card, index) => ({
+        _id: card._id,
+        userId: new import_mongodb90.ObjectId(assignees[index])
+      }));
       const commands = cards.map((item, index) => {
         let ag = null;
         if (item.accessGroup !== void 0) {
@@ -38071,16 +38647,27 @@ function UseAccessManagementRepo() {
           liftAccessEndDate: formatEntryPassDate(item.liftAccessEndDate) || "19770510",
           accessGroup: ag
         };
-        return readTemplate(`${item.accessLevel !== null ? "add-card" : "add-card-lift"}`, { ...command });
+        return readTemplate(
+          `${item.accessLevel !== null ? "add-card" : "add-card-lift"}`,
+          { ...command }
+        );
       }).flat();
       const response = await sendCommand(commands.join("").toString(), acm_url);
-      const result = await (0, import_xml2js2.parseStringPromise)(response, { explicitArray: false });
+      const result = await (0, import_xml2js2.parseStringPromise)(response, {
+        explicitArray: false
+      });
       console.log("status code", result.RESULT.$.STCODE);
       if (result && result.RESULT.$.STCODE !== "0") {
         throw new Error("Command failed, server error.");
       }
       for (const { _id, userId } of update) {
-        await collection().updateOne({ _id }, { $set: { userId, staffNo: `STAFF-${userId.toString().slice(-10)}` } }, { session });
+        await collection().updateOne(
+          { _id },
+          {
+            $set: { userId, staffNo: `STAFF-${userId.toString().slice(-10)}` }
+          },
+          { session }
+        );
       }
       await session?.commitTransaction();
       return "Cards assigned successfully.";
@@ -38096,7 +38683,11 @@ function UseAccessManagementRepo() {
     try {
       session?.startTransaction();
       const id = new import_mongodb90.ObjectId(userId);
-      await collection().updateMany({ userId: id }, { $set: { userId: null, status: "Available" } }, { session });
+      await collection().updateMany(
+        { userId: id },
+        { $set: { userId: null, status: "Available" } },
+        { session }
+      );
       session?.commitTransaction();
       return "Successful Checkout";
     } catch (error) {
@@ -38106,7 +38697,11 @@ function UseAccessManagementRepo() {
       await session?.endSession();
     }
   }
-  async function uploadTemplateRepo({ site, id, name }) {
+  async function uploadTemplateRepo({
+    site,
+    id,
+    name
+  }) {
     site = new import_mongodb90.ObjectId(site);
     id = new import_mongodb90.ObjectId(id);
     try {
@@ -38119,6 +38714,46 @@ function UseAccessManagementRepo() {
       throw new Error(error.message);
     }
   }
+  async function getResidentsRepo({
+    orgId,
+    siteId,
+    unitId
+  }) {
+    try {
+      orgId = new import_mongodb90.ObjectId(orgId);
+      siteId = new import_mongodb90.ObjectId(siteId);
+      unitId = new import_mongodb90.ObjectId(unitId);
+      const result = await collectionName("users").aggregate([
+        {
+          $match: {
+            $expr: {
+              $and: [
+                { $eq: ["$defaultOrg", orgId] },
+                { $eq: ["$site", siteId] },
+                { $eq: ["$unitId", unitId] }
+              ]
+            }
+          }
+        },
+        {
+          $project: {
+            _id: 1,
+            email: 1,
+            unitName: 1,
+            type: 1,
+            status: 1,
+            name: 1,
+            defaultOrg: 1,
+            site: 1,
+            unitId: 1
+          }
+        }
+      ]).toArray();
+      return result;
+    } catch (error) {
+      throw new Error(error.message);
+    }
+  }
   return {
     createIndexes,
     createIndexForEntrypass,
@@ -38154,7 +38789,8 @@ function UseAccessManagementRepo() {
     getTransactionsRepo,
     assignMultipleCardsRepo,
     visitorCheckoutRepo,
-    uploadTemplateRepo
+    uploadTemplateRepo,
+    getResidentsRepo
   };
 }
 
@@ -38198,7 +38834,8 @@ function useAccessManagementSvc() {
     getTransactionsRepo,
     assignMultipleCardsRepo,
     visitorCheckoutRepo,
-    uploadTemplateRepo
+    uploadTemplateRepo,
+    getResidentsRepo
   } = UseAccessManagementRepo();
   const addPhysicalCardSvc = async (payload) => {
     try {
@@ -38490,17 +39127,39 @@ function useAccessManagementSvc() {
       throw new Error(err.message);
     }
   };
-  const getTransactionsSvc = async ({ page, limit, site, cardNo, url }) => {
+  const getTransactionsSvc = async ({
+    page,
+    limit,
+    site,
+    cardNo,
+    url
+  }) => {
     try {
-      const response = await getTransactionsRepo({ page, limit, site, cardNo, url });
+      const response = await getTransactionsRepo({
+        page,
+        limit,
+        site,
+        cardNo,
+        url
+      });
       return response;
     } catch (err) {
       throw new Error(err.message);
     }
   };
-  const assignMultipleCardsSvc = async ({ assignees, unit, type, acm_url }) => {
+  const assignMultipleCardsSvc = async ({
+    assignees,
+    unit,
+    type,
+    acm_url
+  }) => {
     try {
-      const response = await assignMultipleCardsRepo({ assignees, unit, type, acm_url });
+      const response = await assignMultipleCardsRepo({
+        assignees,
+        unit,
+        type,
+        acm_url
+      });
       return response;
     } catch (err) {
       throw new Error(err.message);
@@ -38514,7 +39173,11 @@ function useAccessManagementSvc() {
       throw new Error(err.message);
     }
   };
-  const uploadTemplateSvc = async ({ site, id, name }) => {
+  const uploadTemplateSvc = async ({
+    site,
+    id,
+    name
+  }) => {
     try {
       const response = await uploadTemplateRepo({ site, id, name });
       return response;
@@ -38522,6 +39185,18 @@ function useAccessManagementSvc() {
       throw new Error(err.message);
     }
   };
+  const getResidentsSvc = async ({
+    orgId,
+    siteId,
+    unitId
+  }) => {
+    try {
+      const response = await getResidentsRepo({ orgId, siteId, unitId });
+      return response;
+    } catch (err) {
+      throw new Error(err.message);
+    }
+  };
   return {
     addPhysicalCardSvc,
     addNonPhysicalCardSvc,
@@ -38560,7 +39235,8 @@ function useAccessManagementSvc() {
     getTransactionsSvc,
     assignMultipleCardsSvc,
     visitorCheckoutSvc,
-    uploadTemplateSvc
+    uploadTemplateSvc,
+    getResidentsSvc
   };
 }
 
@@ -38604,7 +39280,8 @@ function useAccessManagementController() {
     getTransactionsSvc,
     assignMultipleCardsSvc,
     visitorCheckoutSvc,
-    uploadTemplateSvc
+    uploadTemplateSvc,
+    getResidentsSvc
   } = useAccessManagementSvc();
   const addPhysicalCard = async (req, res) => {
     try {
@@ -38853,11 +39530,25 @@ function useAccessManagementController() {
         search: import_joi86.default.string().optional().allow("", null),
         userType: import_joi86.default.string().required()
       });
-      const { error } = schema2.validate({ page, limit, site, organization, search, userType });
+      const { error } = schema2.validate({
+        page,
+        limit,
+        site,
+        organization,
+        search,
+        userType
+      });
       if (error) {
         return res.status(400).json({ message: error.message });
       }
-      const result = await userTypeAccessCardsSvc({ page, limit, search, site, organization, userType });
+      const result = await userTypeAccessCardsSvc({
+        page,
+        limit,
+        search,
+        site,
+        organization,
+        userType
+      });
       return res.status(200).json({ message: "Success", data: result });
     } catch (error) {
       return res.status(500).json({
@@ -38868,7 +39559,12 @@ function useAccessManagementController() {
   };
   const assignedAccessCards = async (req, res) => {
     try {
-      const { site, userType, type, search = "" } = req.query;
+      const {
+        site,
+        userType,
+        type,
+        search = ""
+      } = req.query;
       const schema2 = import_joi86.default.object({
         site: import_joi86.default.string().hex().required(),
         userType: import_joi86.default.string().required(),
@@ -38879,7 +39575,12 @@ function useAccessManagementController() {
       if (error) {
         return res.status(400).json({ message: error.message });
       }
-      const result = await assignedAccessCardsSvc({ site, userType, type, search });
+      const result = await assignedAccessCardsSvc({
+        site,
+        userType,
+        type,
+        search
+      });
       return res.status(200).json({ message: "Success", data: result });
     } catch (error) {
       return res.status(500).json({
@@ -38925,11 +39626,23 @@ function useAccessManagementController() {
         userType: import_joi86.default.string().valid(...Object.values(EAccessCardUserTypes)).required(),
         type: import_joi86.default.string().valid(...Object.values(EAccessCardTypes)).required()
       });
-      const { error } = schema2.validate({ accessLevel, liftAccessLevel, site, userType, type });
+      const { error } = schema2.validate({
+        accessLevel,
+        liftAccessLevel,
+        site,
+        userType,
+        type
+      });
       if (error) {
         return res.status(400).json({ message: error.message });
       }
-      const result = await accessandLiftCardsSvc({ accessLevel, liftAccessLevel, site, userType, type });
+      const result = await accessandLiftCardsSvc({
+        accessLevel,
+        liftAccessLevel,
+        site,
+        userType,
+        type
+      });
       return res.status(200).json({ message: "Success", data: result });
     } catch (error) {
       return res.status(500).json({
@@ -39016,11 +39729,23 @@ function useAccessManagementController() {
         issuedCardId: import_joi86.default.string().required(),
         userId: import_joi86.default.string().hex().required()
       });
-      const { error } = schema2.validate({ cardId, remarks, unitId, issuedCardId, userId });
+      const { error } = schema2.validate({
+        cardId,
+        remarks,
+        unitId,
+        issuedCardId,
+        userId
+      });
       if (error) {
         return res.status(400).json({ message: error.message });
       }
-      const result = await cardReplacementSvc({ cardId, remarks, unitId, issuedCardId, userId });
+      const result = await cardReplacementSvc({
+        cardId,
+        remarks,
+        unitId,
+        issuedCardId,
+        userId
+      });
       return res.status(200).json({ message: "Success", data: result });
     } catch (error) {
       return res.status(500).json({
@@ -39049,7 +39774,13 @@ function useAccessManagementController() {
       if (error) {
         return res.status(400).json({ message: error.message });
       }
-      const result = await visitorAccessCardsSvc({ site, page, limit, type, search });
+      const result = await visitorAccessCardsSvc({
+        site,
+        page,
+        limit,
+        type,
+        search
+      });
       return res.status(200).json({ message: "Success", data: result });
     } catch (error) {
       return res.status(500).json({
@@ -39078,11 +39809,27 @@ function useAccessManagementController() {
         limit: import_joi86.default.number().optional().default(10),
         site: import_joi86.default.string().hex().required()
       });
-      const { error } = schema2.validate({ search, statusFilter, dateFrom, dateTo, page, limit, site });
+      const { error } = schema2.validate({
+        search,
+        statusFilter,
+        dateFrom,
+        dateTo,
+        page,
+        limit,
+        site
+      });
       if (error) {
         return res.status(400).json({ message: error.message });
       }
-      const result = await getCardReplacementSvc({ site, page, limit, search, statusFilter, dateFrom, dateTo });
+      const result = await getCardReplacementSvc({
+        site,
+        page,
+        limit,
+        search,
+        statusFilter,
+        dateFrom,
+        dateTo
+      });
       return res.status(200).json({ message: "Success", data: result });
     } catch (error) {
       return res.status(500).json({
@@ -39128,7 +39875,15 @@ function useAccessManagementController() {
   };
   const assignAccessCardToUnit = async (req, res) => {
     try {
-      const { units, type, quantity, site, userType, accessLevel, liftAccessLevel } = req.body;
+      const {
+        units,
+        type,
+        quantity,
+        site,
+        userType,
+        accessLevel,
+        liftAccessLevel
+      } = req.body;
       const schema2 = import_joi86.default.object({
         units: import_joi86.default.array().items(import_joi86.default.string().hex()).required(),
         quantity: import_joi86.default.number().required(),
@@ -39138,11 +39893,27 @@ function useAccessManagementController() {
         accessLevel: import_joi86.default.string().optional().allow("", null),
         liftAccessLevel: import_joi86.default.string().optional().allow("", null)
       });
-      const { error } = schema2.validate({ units, quantity, type, site, userType, accessLevel, liftAccessLevel });
+      const { error } = schema2.validate({
+        units,
+        quantity,
+        type,
+        site,
+        userType,
+        accessLevel,
+        liftAccessLevel
+      });
       if (error) {
         return res.status(400).json({ message: error.message });
       }
-      const result = await assignAccessCardToUnitSvc({ units, quantity, type, site, userType, accessLevel, liftAccessLevel });
+      const result = await assignAccessCardToUnitSvc({
+        units,
+        quantity,
+        type,
+        site,
+        userType,
+        accessLevel,
+        liftAccessLevel
+      });
       return res.status(200).json({ message: "Success", data: result });
     } catch (error) {
       return res.status(500).json({
@@ -39240,7 +40011,12 @@ function useAccessManagementController() {
   };
   const availableCardContractors = async (req, res) => {
     try {
-      const { siteId, unitId, page = 1, limit = 20 } = req.query;
+      const {
+        siteId,
+        unitId,
+        page = 1,
+        limit = 20
+      } = req.query;
       const type = req.params.type;
       const schema2 = import_joi86.default.object({
         siteId: import_joi86.default.string().hex().required(),
@@ -39253,7 +40029,13 @@ function useAccessManagementController() {
       if (error) {
         return res.status(400).json({ message: error.message });
       }
-      const result = await availableCardContractorsSvc({ siteId, unitId, page, limit, type });
+      const result = await availableCardContractorsSvc({
+        siteId,
+        unitId,
+        page,
+        limit,
+        type
+      });
       return res.status(200).json({ message: "Success", data: result });
     } catch (error) {
       return res.status(500).json({
@@ -39264,7 +40046,11 @@ function useAccessManagementController() {
   };
   const vmsgenerateQrCodes = async (req, res) => {
     try {
-      const { site, unitId, quantity = 100 } = req.body;
+      const {
+        site,
+        unitId,
+        quantity = 100
+      } = req.body;
       const schema2 = import_joi86.default.object({
         site: import_joi86.default.string().hex().length(24).required(),
         unitId: import_joi86.default.string().hex().length(24).required(),
@@ -39275,7 +40061,12 @@ function useAccessManagementController() {
         return res.status(400).json({ message: error.message });
       }
       const normalizedUnitId = [unitId];
-      const result = await vmsgenerateQrCodesSvc({ site, unitId, normalizedUnitId, quantity });
+      const result = await vmsgenerateQrCodesSvc({
+        site,
+        unitId,
+        normalizedUnitId,
+        quantity
+      });
       return res.status(200).json({ message: "Success", data: result });
     } catch (error) {
       return res.status(500).json({
@@ -39286,21 +40077,50 @@ function useAccessManagementController() {
   };
   const addVisitorAccessCard = async (req, res) => {
     try {
-      const { site, unitId, quantity = 1, type, nfcCards, visitorId, acm_url } = req.body;
+      const {
+        site,
+        unitId,
+        quantity = 1,
+        type,
+        nfcCards,
+        visitorId,
+        acm_url
+      } = req.body;
       const schema2 = import_joi86.default.object({
         site: import_joi86.default.string().hex().length(24).required(),
         unitId: import_joi86.default.string().hex().length(24).required(),
         quantity: import_joi86.default.number().allow(null, "").optional(),
         type: import_joi86.default.string().required(),
-        nfcCards: import_joi86.default.array().items(import_joi86.default.object({ _id: import_joi86.default.string().hex().required(), cardNo: import_joi86.default.string().required() })).required(),
+        nfcCards: import_joi86.default.array().items(
+          import_joi86.default.object({
+            _id: import_joi86.default.string().hex().required(),
+            cardNo: import_joi86.default.string().required()
+          })
+        ).required(),
         acm_url: import_joi86.default.string().required(),
         visitorId: import_joi86.default.string().hex().length(24).required()
       });
-      const { error } = schema2.validate({ site, unitId, quantity, type, nfcCards, visitorId, acm_url });
+      const { error } = schema2.validate({
+        site,
+        unitId,
+        quantity,
+        type,
+        nfcCards,
+        visitorId,
+        acm_url
+      });
       if (error) {
         return res.status(400).json({ message: error.message });
       }
-      const result = await addVisitorAccessCardSvc({ site, unitId, quantity, type, nfcCards, visitorId, acm_url });
+      const result = await addVisitorAccessCardSvc({
+        site,
+        unitId,
+        quantity,
+        type,
+        nfcCards,
+        visitorId,
+        acm_url
+      });
       return res.status(200).json({ message: "Success", data: result });
     } catch (error) {
       return res.status(500).json({
@@ -39348,7 +40168,11 @@ function useAccessManagementController() {
       });
     }
   };
-  const removeAccessCard = async ({ cardNo, staffNo, url }) => {
+  const removeAccessCard = async ({
+    cardNo,
+    staffNo,
+    url
+  }) => {
     return removeAccessGroup({ cardNo, staffNo, url });
   };
   const getBlockLevelAndUnitList = async (req, res) => {
@@ -39367,7 +40191,13 @@ function useAccessManagementController() {
     }
   };
   const getTransactions2 = async (req, res) => {
-    const { page = 1, limit = 10, site, cardNo, url } = req.query;
+    const {
+      page = 1,
+      limit = 10,
+      site,
+      cardNo,
+      url
+    } = req.query;
     const schema2 = import_joi86.default.object({
       page: import_joi86.default.number().required(),
       limit: import_joi86.default.number().optional().default(10),
@@ -39406,7 +40236,12 @@ function useAccessManagementController() {
       if (error) {
         throw new Error(`${error.message}`);
       }
-      const result = await assignMultipleCardsSvc({ assignees, unit, type, acm_url });
+      const result = await assignMultipleCardsSvc({
+        assignees,
+        unit,
+        type,
+        acm_url
+      });
       return res.status(200).json({ message: "Success", data: result });
     } catch (error) {
       return res.status(400).json({
@@ -39449,6 +40284,27 @@ function useAccessManagementController() {
       });
     }
   };
+  const getResidents = async (req, res) => {
+    try {
+      const { orgId, siteId, unitId } = req.query;
+      const schema2 = import_joi86.default.object({
+        orgId: import_joi86.default.string().hex().required(),
+        siteId: import_joi86.default.string().hex().required(),
+        unitId: import_joi86.default.string().hex().required()
+      });
+      const { error } = schema2.validate({ orgId, siteId, unitId });
+      if (error) {
+        return res.status(400).json({ message: error.message });
+      }
+      const result = await getResidentsSvc({ orgId, siteId, unitId });
+      return res.status(200).json({ data: result });
+    } catch (error) {
+      return res.status(400).json({
+        data: null,
+        message: error.message
+      });
+    }
+  };
   return {
     addPhysicalCard,
     addNonPhysicalCard,
@@ -39485,7 +40341,8 @@ function useAccessManagementController() {
     getTransactions: getTransactions2,
     assignMultipleCards,
     visitorCheckout,
-    uploadTemplate
+    uploadTemplate,
+    getResidents
   };
 }
 
@@ -53444,6 +54301,7 @@ var import_joi132 = __toESM(require("joi"));
 var import_mongodb129 = require("mongodb");
 var PostStatus = /* @__PURE__ */ ((PostStatus2) => {
   PostStatus2["PUBLISHED"] = "published";
+  PostStatus2["RESERVED"] = "reserved";
   PostStatus2["SOLD"] = "sold";
   PostStatus2["DELETED"] = "deleted";
   return PostStatus2;
@@ -53476,6 +54334,17 @@ var schemaPost = import_joi132.default.object({
   updatedAt: import_joi132.default.date().optional().allow(null),
   deletedAt: import_joi132.default.date().optional().allow(null)
 });
+var schemaUpdatePost = import_joi132.default.object({
+  _id: import_joi132.default.string().hex().required(),
+  title: import_joi132.default.string().optional().allow("", null),
+  description: import_joi132.default.string().optional().allow("", null),
+  attachments: import_joi132.default.array().items(import_joi132.default.string().hex().optional()).optional().allow(null),
+  category: import_joi132.default.array().items(import_joi132.default.string().hex().optional()).optional().allow(null),
+  currency: import_joi132.default.string().optional().allow("", null),
+  price: import_joi132.default.number().optional(),
+  status: import_joi132.default.string().valid(...Object.values(PostStatus)).optional().allow(null),
+  reserverId: import_joi132.default.string().hex().optional().allow("", null)
+});
 function MPost(value) {
   const { error } = schemaPost.validate(value);
   if (error) {
@@ -53693,10 +54562,79 @@ function usePostPrelovedRepo() {
       throw error;
     }
   }
+  async function updateById(_id, value, session) {
+    try {
+      _id = new import_mongodb130.ObjectId(_id);
+    } catch {
+      throw new import_node_server_utils232.BadRequestError("Invalid post ID format.");
+    }
+    value.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
+    try {
+      const res = await collection.updateOne(
+        { _id },
+        { $set: value },
+        { session }
+      );
+      if (res.modifiedCount === 0) {
+        throw new import_node_server_utils232.InternalServerError("Unable to update post.");
+      }
+      return res;
+    } catch (error) {
+      throw error;
+    }
+  }
+  async function deleteById(_id, session) {
+    try {
+      _id = new import_mongodb130.ObjectId(_id);
+    } catch {
+      throw new import_node_server_utils232.BadRequestError("Invalid post ID format.");
+    }
+    try {
+      const res = await collection.updateOne(
+        { _id },
+        {
+          $set: {
+            status: "deleted" /* DELETED */,
+            updatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+            deletedAt: (/* @__PURE__ */ new Date()).toISOString()
+          }
+        },
+        { session }
+      );
+      if (res.modifiedCount === 0) {
+        throw new import_node_server_utils232.InternalServerError("Unable to delete post.");
+      }
+      return res.modifiedCount;
+    } catch (error) {
+      throw error;
+    }
+  }
+  async function updateStatus(_id, status, session) {
+    try {
+      _id = new import_mongodb130.ObjectId(_id);
+    } catch {
+      throw new import_node_server_utils232.BadRequestError("Invalid post ID format.");
+    }
+    try {
+      const res = await collection.updateOne(
+        { _id },
+        { $set: { status, updatedAt: (/* @__PURE__ */ new Date()).toISOString() } },
+        { session }
+      );
+      if (res.modifiedCount === 0)
+        throw new import_node_server_utils232.InternalServerError("Unable to update post status.");
+      return res;
+    } catch (error) {
+      throw error;
+    }
+  }
   return {
     add,
     getById,
-    getAll
+    getAll,
+    updateById,
+    deleteById,
+    updateStatus
   };
 }
 
@@ -53707,7 +54645,10 @@ function usePostPrelovedController() {
   const {
     add: _add,
     getById: _getById,
-    getAll: _getAll
+    getAll: _getAll,
+    updateById: _updateById,
+    deleteById: _deleteById,
+    updateStatus: _updateStatus
   } = usePostPrelovedRepo();
   async function add(req, res, next) {
     const { error, value } = schemaPost.validate(req.body, {
@@ -53790,10 +54731,280 @@ function usePostPrelovedController() {
       return;
     }
   }
+  async function updateById(req, res, next) {
+    const _id = req.params.id;
+    const payload = { _id, ...req.body };
+    const { error } = schemaUpdatePost.validate(payload, {
+      abortEarly: false
+    });
+    if (error) {
+      const messages = error.details.map((d) => d.message).join(", ");
+      import_node_server_utils233.logger.log({ level: "error", message: messages });
+      next(new import_node_server_utils233.BadRequestError(messages));
+      return;
+    }
+    try {
+      const data = await _updateById(_id, req.body);
+      res.status(200).json(data);
+      return;
+    } catch (error2) {
+      import_node_server_utils233.logger.log({ level: "error", message: error2.message });
+      next(error2);
+      return;
+    }
+  }
+  async function deleteById(req, res, next) {
+    const schema2 = import_joi133.default.object({
+      _id: import_joi133.default.string().hex().length(24).required()
+    });
+    const { error, value } = schema2.validate({ _id: req.params.id });
+    if (error) {
+      import_node_server_utils233.logger.log({ level: "error", message: error.message });
+      next(new import_node_server_utils233.BadRequestError(error.message));
+      return;
+    }
+    try {
+      const data = await _deleteById(value._id);
+      res.status(200).json({ message: "Successfully deleted post." });
+      return;
+    } catch (error2) {
+      import_node_server_utils233.logger.log({ level: "error", message: error2.message });
+      next(error2);
+      return;
+    }
+  }
+  async function updateStatus(req, res, next) {
+    const schema2 = import_joi133.default.object({
+      _id: import_joi133.default.string().hex().length(24).required(),
+      status: import_joi133.default.string().valid(...Object.values(PostStatus)).required()
+    });
+    const { error, value } = schema2.validate({
+      _id: req.params.id,
+      status: req.body.status
+    });
+    if (error) {
+      import_node_server_utils233.logger.log({ level: "error", message: error.message });
+      next(new import_node_server_utils233.BadRequestError(error.message));
+      return;
+    }
+    try {
+      const data = await _updateStatus(value._id, value.status);
+      res.status(200).json(data);
+      return;
+    } catch (error2) {
+      import_node_server_utils233.logger.log({ level: "error", message: error2.message });
+      next(error2);
+      return;
+    }
+  }
   return {
     add,
     getById,
-    getAll
+    getAll,
+    updateById,
+    deleteById,
+    updateStatus
+  };
+}
+
+// src/models/online-forms-v2.model.ts
+var import_joi134 = __toESM(require("joi"));
+var import_mongodb131 = require("mongodb");
+var FormEntryStatus = /* @__PURE__ */ ((FormEntryStatus2) => {
+  FormEntryStatus2["ACTIVE"] = "active";
+  FormEntryStatus2["INACTIVE"] = "inactive";
+  FormEntryStatus2["DELETED"] = "deleted";
+  return FormEntryStatus2;
+})(FormEntryStatus || {});
+var schemaFormEntry = import_joi134.default.object({
+  _id: import_joi134.default.string().hex().optional().allow("", null),
+  formType: import_joi134.default.string().required(),
+  fields: import_joi134.default.object().pattern(
+    import_joi134.default.string(),
+    import_joi134.default.alternatives().try(
+      import_joi134.default.string(),
+      import_joi134.default.number(),
+      import_joi134.default.boolean(),
+      import_joi134.default.valid(null)
+    )
+  ).required(),
+  status: import_joi134.default.string().optional().allow("", null),
+  org: import_joi134.default.string().hex().optional().allow("", null),
+  site: import_joi134.default.string().hex().optional().allow("", null),
+  createdAt: import_joi134.default.date().optional().allow("", null),
+  updatedAt: import_joi134.default.date().optional().allow("", null),
+  deletedAt: import_joi134.default.date().optional().allow("", null)
+});
+var schemaUpdateFormEntry = import_joi134.default.object({
+  _id: import_joi134.default.string().hex().required(),
+  formType: import_joi134.default.string().optional().allow("", null),
+  fields: import_joi134.default.object().pattern(
+    import_joi134.default.string(),
+    import_joi134.default.alternatives().try(
+      import_joi134.default.string(),
+      import_joi134.default.number(),
+      import_joi134.default.boolean(),
+      import_joi134.default.valid(null)
+    )
+  ).optional(),
+  status: import_joi134.default.string().optional().allow("", null),
+  createdAt: import_joi134.default.date().optional().allow("", null),
+  updatedAt: import_joi134.default.date().optional().allow("", null),
+  deletedAt: import_joi134.default.date().optional().allow("", null)
+});
+function MFormEntry(value) {
+  const { error } = schemaFormEntry.validate(value);
+  if (error) {
+    throw new Error(error.details[0].message);
+  }
+  if (value._id && typeof value._id === "string") {
+    try {
+      value._id = new import_mongodb131.ObjectId(value._id);
+    } catch {
+      throw new Error("Invalid ID.");
+    }
+  }
+  if (value.org && typeof value.org === "string") {
+    try {
+      value.org = new import_mongodb131.ObjectId(value.org);
+    } catch {
+      throw new Error("Invalid org ID.");
+    }
+  }
+  if (value.site && typeof value.site === "string") {
+    try {
+      value.site = new import_mongodb131.ObjectId(value.site);
+    } catch {
+      throw new Error("Invalid site ID.");
+    }
+  }
+  return {
+    _id: value._id,
+    formType: value.formType,
+    fields: value.fields,
+    status: value.status,
+    org: value.org,
+    site: value.site,
+    createdAt: value.createdAt ?? /* @__PURE__ */ new Date(),
+    updatedAt: value.updatedAt ?? null,
+    deletedAt: value.deletedAt ?? null
+  };
+}
+
+// src/repositories/online-forms-v2.repository.ts
+var import_node_server_utils234 = require("@7365admin1/node-server-utils");
+var online_forms_namespace_collection = "online-forms";
+function useFormEntryRepo() {
+  const db = import_node_server_utils234.useAtlas.getDb();
+  if (!db) {
+    throw new import_node_server_utils234.InternalServerError("Unable to connect to server.");
+  }
+  const collection = db.collection(online_forms_namespace_collection);
+  const { delNamespace, getCache, setCache } = (0, import_node_server_utils234.useCache)(
+    online_forms_namespace_collection
+  );
+  async function createTextIndex() {
+    try {
+      await collection.createIndex({
+        name: "text"
+      });
+    } catch (error) {
+      throw new import_node_server_utils234.InternalServerError(
+        "Failed to create text index on online form."
+      );
+    }
+  }
+  async function add(value, session) {
+    try {
+      value = MFormEntry(value);
+      const res = await collection.insertOne(value, { session });
+      delNamespace().then(() => {
+        import_node_server_utils234.logger.info(
+          `Cache cleared for namespace: ${online_forms_namespace_collection}`
+        );
+      }).catch((err) => {
+        import_node_server_utils234.logger.error(
+          `Failed to clear cache for namespace: ${online_forms_namespace_collection}`,
+          err
+        );
+      });
+      return res.insertedId;
+    } catch (error) {
+      const isDuplicated = error.message.includes("duplicate");
+      if (isDuplicated) {
+        throw new import_node_server_utils234.BadRequestError("Online Form already exists.");
+      }
+      throw error;
+    }
+  }
+  return {
+    add,
+    createTextIndex
+  };
+}
+
+// src/controllers/online-forms-v2.controller.ts
+var import_node_server_utils235 = require("@7365admin1/node-server-utils");
+var import_exceljs3 = __toESM(require("exceljs"));
+var import_fs6 = __toESM(require("fs"));
+function useFormEntryController() {
+  const { add: _add } = useFormEntryRepo();
+  function toCamelCase(str) {
+    return str.replace(/\s(.)/g, (_, char) => char.toUpperCase()).replace(/\s+/g, "").replace(/^(.)/, (_, char) => char.toLowerCase());
+  }
+  function normalizeKeys(obj) {
+    const normalized = {};
+    for (const [key, value] of Object.entries(obj)) {
+      normalized[toCamelCase(key)] = value;
+    }
+    return normalized;
+  }
+  async function uploadFormEntrys(req, res, next) {
+    try {
+      if (!req.file) {
+        next(new import_node_server_utils235.BadRequestError("Excel file is required."));
+        return;
+      }
+      const workbook = new import_exceljs3.default.Workbook();
+      await workbook.xlsx.readFile(req.file.path);
+      const worksheet = workbook.worksheets[0];
+      if (!worksheet) {
+        next(new import_node_server_utils235.BadRequestError("No worksheet found in uploaded Excel file."));
+        return;
+      }
+      const headerRow = worksheet.getRow(1);
+      const headers = headerRow.values.slice(1).map((h) => String(h ?? "").trim());
+      const fields = {};
+      headers.forEach((header) => {
+        fields[header] = null;
+      });
+      const formType = req.file.originalname.replace(/\.[^/.]+$/, "");
+      const normalizedFields = normalizeKeys(fields);
+      const payload = {
+        formType,
+        fields: normalizedFields,
+        status: "active" /* ACTIVE */
+      };
+      const { error, value } = schemaFormEntry.validate(payload, {
+        abortEarly: false
+      });
+      if (error) {
+        const messages = error.details.map((d) => d.message).join(", ");
+        import_node_server_utils235.logger.log({ level: "error", message: messages });
+        next(new import_node_server_utils235.BadRequestError(messages));
+        return;
+      }
+      const result = await _add(value);
+      res.status(201).json(result);
+      import_fs6.default.unlink(req.file.path, () => {
+      });
+    } catch (error) {
+      import_node_server_utils235.logger.log({ level: "error", message: error.message });
+      next(error);
+    }
+  }
+  return {
+    uploadFormEntrys
   };
 }
 // Annotate the CommonJS export names for ESM import in node:
@@ -53823,6 +55034,7 @@ function usePostPrelovedController() {
   EventType,
   FacilitySort,
   FacilityStatus,
+  FormEntryStatus,
   GuestSort,
   GuestStatus,
   MAccessCard,
@@ -53844,6 +55056,7 @@ function usePostPrelovedController() {
   MEventManagement,
   MFeedback,
   MFile,
+  MFormEntry,
   MGuestManagement,
   MIncidentReport,
   MManpowerDesignations,
@@ -53955,6 +55168,7 @@ function usePostPrelovedController() {
   nfcPatrolSettingsSchema,
   nfcPatrolSettingsSchemaUpdate,
   occurrence_book_namespace_collection,
+  online_forms_namespace_collection,
   orgSchema,
   overnight_parking_requests_namespace_collection,
   parseDahuaFind,
@@ -53979,6 +55193,7 @@ function usePostPrelovedController() {
   schemaEntryPassSettings,
   schemaEventManagement,
   schemaFiles,
+  schemaFormEntry,
   schemaGuestManagement,
   schemaIncidentReport,
   schemaNfcPatrolLog,
@@ -54009,6 +55224,7 @@ function usePostPrelovedController() {
   schemaUpdateDocumentManagement,
   schemaUpdateEntryPassSettings,
   schemaUpdateEventManagement,
+  schemaUpdateFormEntry,
   schemaUpdateGuestManagement,
   schemaUpdateIncidentReport,
   schemaUpdateOccurrenceBook,
@@ -54021,6 +55237,7 @@ function usePostPrelovedController() {
   schemaUpdatePatrolQuestion,
   schemaUpdatePatrolRoute,
   schemaUpdatePerson,
+  schemaUpdatePost,
   schemaUpdateServiceProviderBilling,
   schemaUpdateSiteBillingConfiguration,
   schemaUpdateSiteBillingItem,
@@ -54091,6 +55308,8 @@ function usePostPrelovedController() {
   useFileController,
   useFileRepo,
   useFileService,
+  useFormEntryController,
+  useFormEntryRepo,
   useGuestManagementController,
   useGuestManagementRepo,
   useGuestManagementService,