@7365admin1/core 2.53.0 → 2.55.0

package/dist/index.js

@@ -155,6 +155,7 @@ __export(src_exports, {
   allowedNatures: () => allowedNatures,
   attendanceSchema: () => attendanceSchema,
   attendanceSettingsSchema: () => attendanceSettingsSchema,
+  building_units_namespace_collection: () => building_units_namespace_collection,
   buildings_namespace_collection: () => buildings_namespace_collection,
   bulletin_boards_namespace_collection: () => bulletin_boards_namespace_collection,
   calculatePercentage: () => calculatePercentage,
@@ -4485,12 +4486,13 @@ function useOrgRepo() {
     status = "active",
     nature = ""
   }) {
-    page = page > 0 ? page - 1 : 0;
     const query = { status };
     sort = Object.keys(sort).length > 0 ? sort : { _id: -1 };
     const cacheOptions = {
       status,
-      sort
+      sort,
+      page,
+      limit
     };
     if (search) {
       query.$text = { $search: search };
@@ -4506,11 +4508,12 @@ function useOrgRepo() {
       import_node_server_utils17.logger.info(`Cache hit for key: ${cacheKey}`);
       return cachedData;
     }
+    const normalizedPage = page > 0 ? page - 1 : 0;
     try {
       const items = await collection.aggregate([
         { $match: query },
         { $sort: sort },
-        { $skip: page * limit },
+        { $skip: normalizedPage * limit },
         { $limit: limit },
         {
           $project: {
@@ -4524,7 +4527,7 @@ function useOrgRepo() {
         }
       ]).toArray();
       const length = await collection.countDocuments(query);
-      const data = (0, import_node_server_utils17.paginate)(items, page, limit, length);
+      const data = (0, import_node_server_utils17.paginate)(items, normalizedPage, limit, length);
       setCache(cacheKey, data, 15 * 60).then(() => {
         import_node_server_utils17.logger.info(`Cache set for key: ${cacheKey}`);
       }).catch((err) => {
@@ -5658,11 +5661,16 @@ function useVerificationService() {
     const existing = await useVerificationRepo().findOne({
       type,
       email,
-      "metadata.org": metadata?.org,
-      "metadata.siteId": metadata?.siteId
+      "metadata.app": metadata.app
     });
-    if (existing)
+    if (existing) {
+      if (existing.status === "complete") {
+        throw new import_node_server_utils21.BadRequestError(
+          `User already completed invite for app: ${metadata.app}`
+        );
+      }
       return existing._id;
+    }
     const value = {
       type,
       email,
@@ -7894,6 +7902,7 @@ function useVerificationController() {
     createServiceProviderInvite: _createServiceProviderInvite,
     createForgetPassword: _createForgetPassword,
     verify: _verify,
+    updateStatusById: _updateStatusById,
     cancelUserInvitation: _cancelUserInvitation
   } = useVerificationService();
   const { getVerifications: _getVerifications } = useVerificationRepo();
@@ -8107,6 +8116,28 @@ function useVerificationController() {
       return;
     }
   }
+  async function updateVerificationStatus(req, res, next) {
+    const validation = import_joi16.default.object({
+      id: import_joi16.default.string().hex().required(),
+      status: import_joi16.default.string().valid("pending", "complete", "expired", "cancelled").required()
+    });
+    const { error } = validation.validate(req.body);
+    if (error) {
+      import_node_server_utils32.logger.log({ level: "error", message: error.message });
+      next(new import_node_server_utils32.BadRequestError(error.message));
+      return;
+    }
+    try {
+      const { id, status } = req.body;
+      const result = await _updateStatusById(id, status);
+      res.json({ message: result });
+      return;
+    } catch (error2) {
+      import_node_server_utils32.logger.log({ level: "error", message: error2.message });
+      next(error2);
+      return;
+    }
+  }
   async function cancelUserInvitation(req, res, next) {
     const validation = import_joi16.default.string().hex().required();
     const otpId = req.params.id;
@@ -8134,6 +8165,7 @@ function useVerificationController() {
     createServiceProviderInvite,
     createForgetPassword,
     verify,
+    updateVerificationStatus,
     cancelUserInvitation,
     createSimpleUserInvite
   };
@@ -13922,9 +13954,26 @@ function useVisitorTransactionRepo() {
       ...status && { status },
       ...tab == "Overnight Parking" && { isOvernightParking: true }
     };
-    sort = Object.keys(sort).length > 0 ? sort : { _id: -1 };
+    sort = Object.keys(sort).length > 0 ? sort : { latestDate: -1 };
     try {
-      const basePipeline = [{ $match: query }];
+      const basePipeline = [
+        { $match: query },
+        {
+          $addFields: {
+            latestDate: {
+              $max: ["$createdAt", "$updatedAt"]
+            }
+          }
+        },
+        { $sort: { latestDate: -1 } },
+        { $skip: skip },
+        { $limit: limit },
+        {
+          $project: {
+            latestDate: 0
+          }
+        }
+      ];
       const [items, countResult] = await Promise.all([
         collection.aggregate([
           ...basePipeline,
@@ -14064,9 +14113,6 @@ function useVisitorTransactionRepo() {
               as: "passKeys"
             }
           },
-          { $sort: sort },
-          { $skip: skip },
-          { $limit: limit },
           {
             $lookup: {
               from: "users",
@@ -16044,14 +16090,16 @@ function MBuildingUnit(value) {
 
 // src/repositories/building-unit.repository.ts
 var import_mongodb45 = require("mongodb");
+var building_units_namespace_collection = "building-units";
 function useBuildingUnitRepo() {
   const db = import_node_server_utils73.useAtlas.getDb();
   if (!db) {
     throw new Error("Unable to connect to server.");
   }
-  const namespace_collection = "building-units";
-  const collection = db.collection(namespace_collection);
-  const { getCache, setCache, delNamespace, delCache } = (0, import_node_server_utils73.useCache)(namespace_collection);
+  const collection = db.collection(building_units_namespace_collection);
+  const { getCache, setCache, delNamespace, delCache } = (0, import_node_server_utils73.useCache)(
+    building_units_namespace_collection
+  );
   async function createIndexes() {
     try {
       await collection.createIndexes([
@@ -16077,12 +16125,12 @@ function useBuildingUnitRepo() {
     delNamespace().then(() => {
       import_node_server_utils73.logger.log({
         level: "info",
-        message: `Cache namespace cleared for ${namespace_collection}`
+        message: `Cache namespace cleared for ${building_units_namespace_collection}`
       });
     }).catch((err) => {
       import_node_server_utils73.logger.log({
         level: "error",
-        message: `Failed to clear cache namespace for ${namespace_collection}: ${err.message}`
+        message: `Failed to clear cache namespace for ${building_units_namespace_collection}: ${err.message}`
       });
     });
   }
@@ -16229,7 +16277,10 @@ function useBuildingUnitRepo() {
       ...building && { building },
       ...status && { status }
     };
-    const cacheKey = (0, import_node_server_utils73.makeCacheKey)(namespace_collection, cacheParams);
+    const cacheKey = (0, import_node_server_utils73.makeCacheKey)(
+      building_units_namespace_collection,
+      cacheParams
+    );
     import_node_server_utils73.logger.log({
       level: "info",
       message: `Cache key for getAll building units: ${cacheKey}`
@@ -16300,7 +16351,9 @@ function useBuildingUnitRepo() {
     } catch (error) {
       throw new import_node_server_utils73.BadRequestError("Invalid ID.");
     }
-    const cacheKey = (0, import_node_server_utils73.makeCacheKey)(namespace_collection, { _id: String(_id) });
+    const cacheKey = (0, import_node_server_utils73.makeCacheKey)(building_units_namespace_collection, {
+      _id: String(_id)
+    });
     try {
       const cached = await getCache(cacheKey);
       if (cached) {
@@ -16343,7 +16396,7 @@ function useBuildingUnitRepo() {
     } catch (error) {
       throw new import_node_server_utils73.BadRequestError("Invalid building ID.");
     }
-    const cacheKey = (0, import_node_server_utils73.makeCacheKey)(namespace_collection, {
+    const cacheKey = (0, import_node_server_utils73.makeCacheKey)(building_units_namespace_collection, {
       building: String(building),
       level
     });
@@ -16417,7 +16470,7 @@ function useBuildingUnitRepo() {
     } catch (error) {
       throw new import_node_server_utils73.BadRequestError("Invalid building ID.");
     }
-    const cacheKey = (0, import_node_server_utils73.makeCacheKey)(namespace_collection, {
+    const cacheKey = (0, import_node_server_utils73.makeCacheKey)(building_units_namespace_collection, {
       building: String(building)
     });
     try {
@@ -16491,7 +16544,10 @@ function useBuildingUnitRepo() {
       block,
       level
     };
-    const cacheKey = (0, import_node_server_utils73.makeCacheKey)(namespace_collection, cacheOptions);
+    const cacheKey = (0, import_node_server_utils73.makeCacheKey)(
+      building_units_namespace_collection,
+      cacheOptions
+    );
     const cachedData = await getCache(cacheKey);
     if (cachedData) {
       import_node_server_utils73.logger.info(`Cache hit for key: ${cacheKey}`);
@@ -16529,7 +16585,10 @@ function useBuildingUnitRepo() {
     const cacheOptions = {
       site: site.toString()
     };
-    const cacheKey = (0, import_node_server_utils73.makeCacheKey)(namespace_collection, cacheOptions);
+    const cacheKey = (0, import_node_server_utils73.makeCacheKey)(
+      building_units_namespace_collection,
+      cacheOptions
+    );
     const cachedData = await getCache(cacheKey);
     if (cachedData) {
       import_node_server_utils73.logger.info(`Cache hit for key: ${cacheKey}`);
@@ -16577,7 +16636,10 @@ function useBuildingUnitRepo() {
         { deletedAt: "" }
       ]
     };
-    const cacheKey = (0, import_node_server_utils73.makeCacheKey)(namespace_collection, cacheOptions);
+    const cacheKey = (0, import_node_server_utils73.makeCacheKey)(
+      building_units_namespace_collection,
+      cacheOptions
+    );
     try {
       const cached = await getCache(cacheKey);
       if (cached) {
@@ -16613,6 +16675,54 @@ function useBuildingUnitRepo() {
       }
     }
   }
+  async function getBySiteBuildingLevel(site, block, level) {
+    try {
+      site = new import_mongodb45.ObjectId(site);
+    } catch (error) {
+      throw new import_node_server_utils73.BadRequestError("Invalid site ID.");
+    }
+    const cacheKey = (0, import_node_server_utils73.makeCacheKey)(building_units_namespace_collection, {
+      site: site.toString(),
+      block,
+      level
+    });
+    try {
+      const cached = await getCache(cacheKey);
+      if (cached) {
+        import_node_server_utils73.logger.log({
+          level: "info",
+          message: `Cache hit for getById building unit: ${cacheKey}`
+        });
+        return cached;
+      }
+      const query = {
+        site,
+        block,
+        level,
+        status: "active"
+      };
+      console.log(query);
+      const result = await collection.findOne(query);
+      setCache(cacheKey, result, 300).then(() => {
+        import_node_server_utils73.logger.log({
+          level: "info",
+          message: `Cache set for building unit by id: ${cacheKey}`
+        });
+      }).catch((err) => {
+        import_node_server_utils73.logger.log({
+          level: "error",
+          message: `Failed to set cache for building unit by id: ${err.message}`
+        });
+      });
+      return result;
+    } catch (error) {
+      if (error instanceof import_node_server_utils73.AppError) {
+        throw error;
+      } else {
+        throw new import_node_server_utils73.InternalServerError("Failed to get building unit.");
+      }
+    }
+  }
   return {
     createIndexes,
     add,
@@ -16626,7 +16736,8 @@ function useBuildingUnitRepo() {
     updateByBuildingId,
     getBuildingUnits,
     getBuildingUnitsWithOwner,
-    getUnitByBlockLevelUnitNumber
+    getUnitByBlockLevelUnitNumber,
+    getBySiteBuildingLevel
   };
 }
 
@@ -19288,6 +19399,7 @@ function useBuildingRepo() {
       throw new Error("Failed to create index on buildings. " + error.message);
     }
   }
+  const { getBySiteBuildingLevel: _getBySiteBuildingLevel } = useBuildingUnitRepo();
   async function add(value, session) {
     try {
       value = MBuilding(value);
@@ -19523,6 +19635,94 @@ function useBuildingRepo() {
       }
     }
   }
+  async function getBuildingLevelWithUnits(site, block) {
+    try {
+      site = new import_mongodb49.ObjectId(site);
+    } catch (error) {
+      throw new import_node_server_utils82.BadRequestError("Invalid ID.");
+    }
+    const query = {
+      site,
+      _id: new import_mongodb49.ObjectId(block)
+    };
+    const cacheOptions = { ...query };
+    const cacheKey = (0, import_node_server_utils82.makeCacheKey)(buildings_namespace_collection, cacheOptions);
+    try {
+      console.log(query);
+      const result = await collection.aggregate([
+        {
+          $match: {
+            ...query
+          }
+        },
+        {
+          $lookup: {
+            from: "building-levels",
+            let: { buildingId: "$_id" },
+            pipeline: [
+              {
+                $match: {
+                  $expr: { $eq: ["$block", "$$buildingId"] }
+                }
+              },
+              {
+                $lookup: {
+                  from: "building-units",
+                  let: { levelId: "$_id" },
+                  pipeline: [
+                    {
+                      $match: {
+                        $expr: {
+                          $and: [
+                            { $eq: ["$site", site] },
+                            { $eq: ["$block", "$$buildingId"] },
+                            { $eq: ["$level", "$$levelId"] },
+                            { $eq: ["$status", "active"] }
+                          ]
+                        }
+                      }
+                    }
+                  ],
+                  as: "buildingUnits"
+                }
+              },
+              // discard levels that have no active units
+              {
+                $match: {
+                  $expr: { $gt: [{ $size: "$buildingUnits" }, 0] }
+                }
+              }
+            ],
+            as: "buildingLevels"
+          }
+        },
+        {
+          $project: {
+            "_id": 1,
+            "site": 1,
+            "name": 1,
+            "block": 1,
+            "status": 1,
+            "buildingFloorPlan": 1,
+            "createdAt": 1,
+            "updatedAt": 1,
+            "deletedAt": 1,
+            "levels": "$buildingLevels"
+          }
+        }
+      ]).toArray();
+      if (!result) {
+        throw new import_node_server_utils82.BadRequestError("Building not found.");
+      }
+      return result;
+    } catch (error) {
+      if (error instanceof import_node_server_utils82.AppError) {
+        throw error;
+      } else {
+        throw new import_node_server_utils82.InternalServerError("Failed to get building.");
+      }
+    }
+  }
   function delCachedData() {
     delNamespace().then(() => {
       import_node_server_utils82.logger.log({
@@ -19543,7 +19743,8 @@ function useBuildingRepo() {
     getById,
     updateById,
     deleteById,
-    getBuildingLevel
+    getBuildingLevel,
+    getBuildingLevelWithUnits
   };
 }
 
@@ -19697,7 +19898,8 @@ function useBuildingController() {
   const {
     getAll: _getAll,
     getById: _getById,
-    getBuildingLevel: _getBuildingLevel
+    getBuildingLevel: _getBuildingLevel,
+    getBuildingLevelWithUnits: _getBuildingLevelWithUnits
   } = useBuildingRepo();
   const {
     updateById: _updateById,
@@ -19966,6 +20168,26 @@ function useBuildingController() {
       next(error);
     }
   }
+  async function getBuildingLevelWithUnits(req, res, next) {
+    const site = req.params.site ?? "";
+    let block = req.query.block;
+    const validation = import_joi44.default.object({
+      site: import_joi44.default.string().hex().required(),
+      block: import_joi44.default.string().required()
+    });
+    const { error } = validation.validate({ site, block });
+    if (error) {
+      next(new import_node_server_utils84.BadRequestError(error.message));
+      return;
+    }
+    try {
+      const siteBlock = await _getBuildingLevelWithUnits(site, block);
+      res.json(siteBlock);
+      return;
+    } catch (error2) {
+      next(error2);
+    }
+  }
   return {
     createBuilding,
     getAll,
@@ -19973,7 +20195,8 @@ function useBuildingController() {
     updateById,
     deleteById,
     getBuildingLevel,
-    uploadSpreadsheetBuilding
+    uploadSpreadsheetBuilding,
+    getBuildingLevelWithUnits
   };
 }
 
@@ -23832,7 +24055,10 @@ function useVisitorTransactionService() {
             nric: value.nric,
             start,
             end,
-            recNo: value.recNo
+            recNo: value.recNo,
+            ...value.block && { block: value.block },
+            ...value.level && { level: value.level },
+            ...value.unit && { unit: new import_mongodb59.ObjectId(value.unit) }
           };
           await addVehicle(vehiclePayload);
         } else {
@@ -23964,6 +24190,8 @@ function useVisitorTransactionService() {
       }
       if (value.unit) {
         value.unit = typeof value.unit === "string" ? new import_mongodb59.ObjectId(value.unit) : value.unit;
+        const unit = await _getUnitById(value.unit);
+        value.unitName = unit?.name;
       }
       await _updateVisitorTansactionById(id, value, session);
       await session?.commitTransaction();
@@ -32677,21 +32905,23 @@ function useEventManagementController() {
     }
   }
   async function deleteEventManagementById(req, res, next) {
-    const validation = import_joi82.default.string().hex().required();
-    const _id = req.params.id;
-    const { error } = validation.validate(_id);
-    if (error) {
-      import_node_server_utils148.logger.log({ level: "error", message: error.message });
-      next(new import_node_server_utils148.BadRequestError(error.message));
-      return;
-    }
     try {
+      const schema2 = import_joi82.default.object({
+        _id: import_joi82.default.string().hex().length(24).required()
+      });
+      const { error, value } = schema2.validate({ _id: req.params.id });
+      if (error) {
+        import_node_server_utils148.logger.log({ level: "error", message: error.message });
+        next(new import_node_server_utils148.BadRequestError(error.message));
+        return;
+      }
+      const { _id } = value;
       await _deleteEventManagementById(_id);
       res.status(200).json({ message: "Successfully deleted event." });
       return;
-    } catch (error2) {
-      import_node_server_utils148.logger.log({ level: "error", message: error2.message });
-      next(error2);
+    } catch (error) {
+      import_node_server_utils148.logger.log({ level: "error", message: error.message });
+      next(error);
       return;
     }
   }
@@ -36262,7 +36492,111 @@ function UseAccessManagementRepo() {
       const items = result[0].items;
       return (0, import_node_server_utils153.paginate)(items, page, limit, length);
     } catch (error) {
-      return Promise.reject("Server internal error.");
+      throw new Error(error.message);
+    }
+  }
+  async function assignMultipleCardsRepo({
+    assignees,
+    unit,
+    type,
+    acm_url
+  }) {
+    const session = import_node_server_utils153.useAtlas.getClient()?.startSession();
+    try {
+      session?.startTransaction();
+      if (assignees.length < 1) {
+        throw new Error("No user to Assign.");
+      }
+      assignees = assignees.map((data) => new import_mongodb90.ObjectId(data));
+      unit = new import_mongodb90.ObjectId(unit);
+      let availableCards = [];
+      let update = [];
+      let cards = [];
+      availableCards = await collection().aggregate([
+        {
+          $match: {
+            $expr: {
+              $and: [
+                { $eq: ["$assignedUnit", unit] },
+                { $eq: ["$userId", null] },
+                { $eq: ["$type", type] },
+                { $eq: ["$isActivated", true] }
+              ]
+            }
+          }
+        }
+      ]).toArray();
+      if (assignees.length > availableCards.length) {
+        throw new Error(`Not enough ${type} cards available.`);
+      }
+      cards = availableCards?.slice(0, assignees.length).map((card, index) => {
+        const userId = new import_mongodb90.ObjectId(assignees[index].toString());
+        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]) }));
+      const commands = cards.map((item, index) => {
+        let ag = null;
+        if (item.accessGroup !== void 0) {
+          if (item.accessGroup?.length > 0) {
+            ag = item.accessGroup.map((g) => `<GROUP_NAME>${g}</GROUP_NAME>`).join("\n  ");
+          }
+        }
+        const command = {
+          commandId1: index * 2 + 1,
+          commandId2: index * 2 + 2,
+          staffName: `STAFF-${item._id.toString().slice(-10)}`,
+          staffNo1: `STAFF-${item._id.toString().slice(-10)}`,
+          staffNo2: `STAFF-${item._id.toString().slice(-10)}`,
+          dateOfJoin: formatEntryPassDate(item.startDate),
+          accessLevel: item.accessLevel ?? "0",
+          cardNo: item.cardNo,
+          pin: typeof item.pin === "string" && item.pin.trim() !== "" ? item.pin : "123456",
+          startDate: formatEntryPassDate(item.startDate),
+          endDate: formatEntryPassDate(item.endDate),
+          cardType: 0,
+          isActivated: item.isActivated ? 1 : 0,
+          isAntiPassBack: item.isAntiPassBack ? 1 : 0,
+          isLiftCard: item.isLiftCard ? 1 : 0,
+          isLiftActivate: item.isLiftCard ? 1 : 0,
+          liftAccessLevel: item.liftAccessLevel || 1,
+          liftAccessStartDate: formatEntryPassDate(item.liftAccessStartDate) || "19770510",
+          liftAccessEndDate: formatEntryPassDate(item.liftAccessEndDate) || "19770510",
+          accessGroup: ag
+        };
+        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 });
+      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 session?.commitTransaction();
+      return "Cards assigned successfully.";
+    } catch (error) {
+      await session?.abortTransaction();
+      throw new Error(error.message);
+    } finally {
+      await session?.endSession();
+    }
+  }
+  async function visitorCheckoutRepo({ userId }) {
+    const session = import_node_server_utils153.useAtlas.getClient()?.startSession();
+    try {
+      session?.startTransaction();
+      const id = new import_mongodb90.ObjectId(userId);
+      await collection().updateMany({ userId: id }, { $set: { userId: null, status: "Available" } }, { session });
+      session?.commitTransaction();
+      return "Successful Checkout";
+    } catch (error) {
+      await session?.abortTransaction();
+      throw new Error(error.message);
+    } finally {
+      await session?.endSession();
     }
   }
   return {
@@ -36297,7 +36631,9 @@ function UseAccessManagementRepo() {
     checkoutVisitorRepo,
     getBlockLevelAndUnitListRepo,
     indexCombination,
-    getTransactionsRepo
+    getTransactionsRepo,
+    assignMultipleCardsRepo,
+    visitorCheckoutRepo
   };
 }
 
@@ -36338,7 +36674,9 @@ function useAccessManagementSvc() {
     signQrCodeRepo,
     checkoutVisitorRepo,
     getBlockLevelAndUnitListRepo,
-    getTransactionsRepo
+    getTransactionsRepo,
+    assignMultipleCardsRepo,
+    visitorCheckoutRepo
   } = UseAccessManagementRepo();
   const addPhysicalCardSvc = async (payload) => {
     try {
@@ -36634,6 +36972,22 @@ function useAccessManagementSvc() {
     try {
       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 }) => {
+    try {
+      const response = await assignMultipleCardsRepo({ assignees, unit, type, acm_url });
+      return response;
+    } catch (err) {
+      throw new Error(err.message);
+    }
+  };
+  const visitorCheckoutSvc = async ({ userId }) => {
+    try {
+      const response = await visitorCheckoutRepo({ userId });
+      return response;
     } catch (err) {
       return Promise.reject("Server internal error.");
     }
@@ -36673,7 +37027,9 @@ function useAccessManagementSvc() {
     signQrCodeSvc,
     checkoutVisitorSvc,
     getBlockLevelAndUnitListSvc,
-    getTransactionsSvc
+    getTransactionsSvc,
+    assignMultipleCardsSvc,
+    visitorCheckoutSvc
   };
 }
 
@@ -36714,7 +37070,9 @@ function useAccessManagementController() {
     signQrCodeSvc,
     checkoutVisitorSvc,
     getBlockLevelAndUnitListSvc,
-    getTransactionsSvc
+    getTransactionsSvc,
+    assignMultipleCardsSvc,
+    visitorCheckoutSvc
   } = useAccessManagementSvc();
   const addPhysicalCard = async (req, res) => {
     try {
@@ -37498,6 +37856,39 @@ function useAccessManagementController() {
       });
       return res.json(result);
     } catch (error2) {
+      return res.status(400).json({
+        data: null,
+        message: error2.message
+      });
+    }
+  };
+  const assignMultipleCards = async (req, res) => {
+    try {
+      const { assignees, unit, type, acm_url } = req.body;
+      const schema2 = import_joi85.default.object({
+        assignees: import_joi85.default.array().items(import_joi85.default.string().hex()).required(),
+        type: import_joi85.default.string().required(),
+        unit: import_joi85.default.string().hex().required()
+      });
+      const { error } = schema2.validate({ assignees, type, unit });
+      if (error) {
+        throw new Error(`${error.message}`);
+      }
+      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({
+        data: null,
+        message: error.message
+      });
+    }
+  };
+  const visitorCheckout = async (req, res) => {
+    try {
+      const userId = req.params.userId;
+      const result = await visitorCheckoutSvc({ userId });
+      return res.status(200).json({ message: "Success", data: result });
+    } catch (error) {
       return Promise.reject("Internal Server Error");
     }
   };
@@ -37534,7 +37925,9 @@ function useAccessManagementController() {
     checkoutVisitor,
     removeAccessCard,
     getBlockLevelAndUnitList,
-    getTransactions: getTransactions2
+    getTransactions: getTransactions2,
+    assignMultipleCards,
+    visitorCheckout
   };
 }
 
@@ -51572,6 +51965,7 @@ function useRoleControllerV2() {
   allowedNatures,
   attendanceSchema,
   attendanceSettingsSchema,
+  building_units_namespace_collection,
   buildings_namespace_collection,
   bulletin_boards_namespace_collection,
   calculatePercentage,