@7365admin1/core 2.10.0 → 2.12.0

package/dist/index.mjs

@@ -934,6 +934,7 @@ function useWorkOrderRepo() {
     }
   }
   const { delNamespace, setCache, getCache, delCache } = useCache3(namespace_collection);
+  const { delNamespace: _delDashboardNameSpace } = useCache3("dashboard");
   async function createWorkOrder(value, session) {
     try {
       value = MWorkOrder(value);
@@ -946,6 +947,11 @@ function useWorkOrderRepo() {
           err
         );
       });
+      _delDashboardNameSpace().then(() => {
+        logger5.info(`Cache cleared for namespace: dashboard`);
+      }).catch((err) => {
+        logger5.error(`Failed to clear cache for namespace: dashboard`, err);
+      });
       return res.insertedId;
     } catch (error) {
       throw error;
@@ -1182,11 +1188,18 @@ function useWorkOrderRepo() {
       if (res.modifiedCount === 0) {
         throw new InternalServerError3("Unable to update work order.");
       }
-      const cacheKey = makeCacheKey3(namespace_collection, { _id });
-      delCache(cacheKey).then(() => {
-        logger5.info(`Cache deleted for key: ${cacheKey}`);
+      delNamespace().then(() => {
+        logger5.info(`Cache cleared for namespace: ${namespace_collection}`);
+      }).catch((err) => {
+        logger5.error(
+          `Failed to clear cache for namespace: ${namespace_collection}`,
+          err
+        );
+      });
+      _delDashboardNameSpace().then(() => {
+        logger5.info(`Cache cleared for namespace: dashboard`);
       }).catch((err) => {
-        logger5.error(`Failed to delete cache for key: ${cacheKey}`, err);
+        logger5.error(`Failed to clear cache for namespace: dashboard`, err);
       });
       return res.modifiedCount;
     } catch (error) {
@@ -1209,11 +1222,18 @@ function useWorkOrderRepo() {
       if (res.modifiedCount === 0) {
         throw new InternalServerError3("Unable to update work order status.");
       }
-      const cacheKey = makeCacheKey3(namespace_collection, { _id });
-      delCache(cacheKey).then(() => {
-        logger5.info(`Cache deleted for key: ${cacheKey}`);
+      delNamespace().then(() => {
+        logger5.info(`Cache cleared for namespace: ${namespace_collection}`);
       }).catch((err) => {
-        logger5.error(`Failed to delete cache for key: ${cacheKey}`, err);
+        logger5.error(
+          `Failed to clear cache for namespace: ${namespace_collection}`,
+          err
+        );
+      });
+      _delDashboardNameSpace().then(() => {
+        logger5.info(`Cache cleared for namespace: dashboard`);
+      }).catch((err) => {
+        logger5.error(`Failed to clear cache for namespace: dashboard`, err);
       });
       return res.modifiedCount;
     } catch (error) {
@@ -1231,11 +1251,18 @@ function useWorkOrderRepo() {
         { $set: updateValue },
         session
       );
-      const cacheKey = makeCacheKey3(namespace_collection, { createdBy: _id });
-      delCache(cacheKey).then(() => {
-        logger5.info(`Cache deleted for key: ${cacheKey}`);
+      delNamespace().then(() => {
+        logger5.info(`Cache cleared for namespace: ${namespace_collection}`);
       }).catch((err) => {
-        logger5.error(`Failed to delete cache for key: ${cacheKey}`, err);
+        logger5.error(
+          `Failed to clear cache for namespace: ${namespace_collection}`,
+          err
+        );
+      });
+      _delDashboardNameSpace().then(() => {
+        logger5.info(`Cache cleared for namespace: dashboard`);
+      }).catch((err) => {
+        logger5.error(`Failed to clear cache for namespace: dashboard`, err);
       });
       return res.modifiedCount;
     } catch (error) {
@@ -1265,11 +1292,18 @@ function useWorkOrderRepo() {
           "Unable to mark work order as completed."
         );
       }
-      const cacheKey = makeCacheKey3(namespace_collection, { _id });
-      delCache(cacheKey).then(() => {
-        logger5.info(`Cache deleted for key: ${cacheKey}`);
+      delNamespace().then(() => {
+        logger5.info(`Cache cleared for namespace: ${namespace_collection}`);
+      }).catch((err) => {
+        logger5.error(
+          `Failed to clear cache for namespace: ${namespace_collection}`,
+          err
+        );
+      });
+      _delDashboardNameSpace().then(() => {
+        logger5.info(`Cache cleared for namespace: dashboard`);
       }).catch((err) => {
-        logger5.error(`Failed to delete cache for key: ${cacheKey}`, err);
+        logger5.error(`Failed to clear cache for namespace: dashboard`, err);
       });
       return res.modifiedCount;
     } catch (error) {
@@ -1296,11 +1330,18 @@ function useWorkOrderRepo() {
       if (res.modifiedCount === 0) {
         throw new InternalServerError3("Unable to delete work order.");
       }
-      const cacheKey = makeCacheKey3(namespace_collection, { _id });
-      delCache(cacheKey).then(() => {
-        logger5.info(`Cache deleted for key: ${cacheKey}`);
+      delNamespace().then(() => {
+        logger5.info(`Cache cleared for namespace: ${namespace_collection}`);
+      }).catch((err) => {
+        logger5.error(
+          `Failed to clear cache for namespace: ${namespace_collection}`,
+          err
+        );
+      });
+      _delDashboardNameSpace().then(() => {
+        logger5.info(`Cache cleared for namespace: dashboard`);
       }).catch((err) => {
-        logger5.error(`Failed to delete cache for key: ${cacheKey}`, err);
+        logger5.error(`Failed to clear cache for namespace: dashboard`, err);
       });
       return res.modifiedCount;
     } catch (error) {
@@ -2858,6 +2899,14 @@ function useVerificationRepo() {
       throw new InternalServerError7("Error updating verification status.");
     }
   }
+  async function getByStatus(status) {
+    try {
+      const data = await collection.find({ status }).toArray();
+      return data;
+    } catch (error) {
+      return Promise.reject(error);
+    }
+  }
   return {
     createIndex,
     createTextIndex,
@@ -2865,7 +2914,8 @@ function useVerificationRepo() {
     getById,
     getVerifications,
     getByIdByType,
-    updateStatusById
+    updateStatusById,
+    getByStatus
   };
 }
 
@@ -4119,7 +4169,8 @@ function useVerificationService() {
   const {
     add,
     getById: _getById,
-    updateStatusById: _updateStatusById
+    updateStatusById: _updateStatusById,
+    getByStatus: _getByStatus
   } = useVerificationRepo();
   const { getUserByEmail } = useUserRepo();
   const { getById: getOrgById, getByEmail: getOrgByEmail } = useOrgRepo();
@@ -4365,7 +4416,6 @@ function useVerificationService() {
   }
   async function cancelUserInvitation(id) {
     try {
-      await verify(id);
       await updateStatusById(id, "cancelled");
     } catch (error) {
       throw new InternalServerError11(
@@ -4427,6 +4477,30 @@ function useVerificationService() {
       throw error;
     }
   }
+  async function checkExpiredInvitation() {
+    const session = useAtlas10.getClient()?.startSession();
+    session?.startTransaction();
+    try {
+      const verifications = await _getByStatus("pending");
+      for (const verification of verifications) {
+        const expiration = new Date(verification.expireAt).getTime();
+        const now = (/* @__PURE__ */ new Date()).getTime();
+        if (now > expiration) {
+          await _updateStatusById(verification._id.toString(), "expired");
+        }
+      }
+      return "Successfully checked for expired invitations.";
+    } catch (error) {
+      await session?.abortTransaction();
+      logger14.log({
+        level: "info",
+        message: `Error checking expired user invitation: ${error}`
+      });
+      throw error;
+    } finally {
+      session?.endSession();
+    }
+  }
   return {
     createUserInvite,
     createForgetPassword,
@@ -4435,7 +4509,8 @@ function useVerificationService() {
     verify,
     cancelUserInvitation,
     updateStatusById,
-    signUp
+    signUp,
+    checkExpiredInvitation
   };
 }
 
@@ -5322,6 +5397,7 @@ function useRoleRepo() {
     }
   }
   const { delNamespace, setCache, getCache, delCache } = useCache12(namespace_collection);
+  const { delNamespace: _delDashboardNameSpace } = useCache12("dashboard");
   async function addRole(value, session) {
     value = new MRole(value);
     try {
@@ -5584,15 +5660,21 @@ function useRoleRepo() {
         { session }
       );
       if (res.modifiedCount === 0) {
-        throw new InternalServerError13("Unable to update feedback status.");
+        throw new InternalServerError13("Unable to update role status.");
       }
-      const cacheKey = makeCacheKey11(namespace_collection, { _id });
-      delCache(cacheKey).then(() => {
-        logger16.info(`Cache deleted for key: ${cacheKey}`);
+      delNamespace().then(() => {
+        logger16.info(`Cache cleared for namespace: ${namespace_collection}`);
       }).catch((err) => {
-        logger16.error(`Failed to delete cache for key: ${cacheKey}`, err);
+        logger16.error(
+          `Failed to clear cache for namespace: ${namespace_collection}`,
+          err
+        );
+      });
+      _delDashboardNameSpace().then(() => {
+        logger16.info(`Cache cleared for namespace: dashboard`);
+      }).catch((err) => {
+        logger16.error(`Failed to clear cache for namespace: dashboard`, err);
       });
-      return "Successfully deleted role.";
     } catch (error) {
       throw new InternalServerError13("Failed to delete role.");
     }
@@ -5645,6 +5727,16 @@ function useFileRepo() {
   const namespace_collection = "files";
   const collection = db.collection(namespace_collection);
   const { delNamespace, getCache, setCache } = useCache13(namespace_collection);
+  async function createIndex() {
+    try {
+      await collection.createIndexes([
+        { key: { createdAt: 1 } },
+        { key: { status: 1 } }
+      ]);
+    } catch (error) {
+      throw new InternalServerError14("Failed to create index on feedback.");
+    }
+  }
   async function createFile(value, session) {
     try {
       value = new MFile(value);
@@ -5773,7 +5865,8 @@ function useFileRepo() {
     deleteFileById,
     getAllDraftedFiles,
     updateStatusById,
-    getFileById
+    getFileById,
+    createIndex
   };
 }
 
@@ -6678,7 +6771,7 @@ function useRoleController() {
   }
   async function deleteRole(req, res, next) {
     const validation = Joi15.string().hex().required();
-    const _id = req.params.id;
+    const _id = req.query.id;
     const { error } = validation.validate(_id);
     if (error) {
       logger21.log({ level: "error", message: error.message });
@@ -7329,7 +7422,7 @@ function useFileController() {
   }
   async function deleteFile(req, res, next) {
     const validation = Joi18.string().hex().required();
-    const _id = req.params.id;
+    const _id = req.query.id;
     const { error } = validation.validate(_id);
     if (error) {
       logger25.log({ level: "error", message: error.message });
@@ -10807,7 +10900,6 @@ function useFeedbackController() {
   async function deleteFeedback(req, res, next) {
     const validation = Joi28.string().hex().required();
     const _id = req.query.id;
-    console.log(_id);
     const { error } = validation.validate(_id);
     if (error) {
       logger39.log({ level: "error", message: error.message });
@@ -20756,13 +20848,38 @@ function usePatrolRouteRepo() {
       throw error;
     }
   }
+  async function getById(_id, session) {
+    try {
+      _id = new ObjectId60(_id);
+    } catch (error) {
+      throw new BadRequestError107("Invalid patrol log ID format.");
+    }
+    const cacheKey = makeCacheKey33(namespace_collection, { _id });
+    const cachedData = await getCache(cacheKey);
+    if (cachedData) {
+      logger89.info(`Cache hit for key: ${cacheKey}`);
+      return cachedData;
+    }
+    try {
+      const data = await collection.findOne({ _id }, { session });
+      setCache(cacheKey, data, 15 * 60).then(() => {
+        logger89.info(`Cache set for key: ${cacheKey}`);
+      }).catch((err) => {
+        logger89.error(`Failed to set cache for key: ${cacheKey}`, err);
+      });
+      return data;
+    } catch (error) {
+      throw error;
+    }
+  }
   return {
     createTextIndex,
     add,
     getAll,
     updateById,
     deleteById,
-    getScheduledRoute
+    getScheduledRoute,
+    getById
   };
 }
 
@@ -20775,7 +20892,8 @@ function usePatrolRouteController() {
     getAll: _getAll,
     updateById: _updateById,
     deleteById: _deleteById,
-    getScheduledRoute: _getScheduledRoute
+    getScheduledRoute: _getScheduledRoute,
+    getById: _getById
   } = usePatrolRouteRepo();
   async function add(req, res, next) {
     const data = { ...req.body };
@@ -20943,12 +21061,34 @@ function usePatrolRouteController() {
       return;
     }
   }
+  async function getById(req, res, next) {
+    const id = req.params.id;
+    const validation = Joi64.object({
+      id: Joi64.string().hex().required()
+    });
+    const { error } = validation.validate({ id });
+    if (error) {
+      next(new BadRequestError108(error.message));
+      return;
+    }
+    try {
+      const routes = await _getById(id);
+      res.json({
+        message: "Successfully retrieved patrol routes.",
+        data: routes
+      });
+      return;
+    } catch (error2) {
+      next(error2);
+    }
+  }
   return {
     add,
     getAll,
     updateById,
     deleteById,
-    getScheduledRoute
+    getScheduledRoute,
+    getById
   };
 }
 
@@ -21207,6 +21347,30 @@ function usePatrolLogRepo() {
       throw error;
     }
   }
+  async function getById(_id, session) {
+    try {
+      _id = new ObjectId62(_id);
+    } catch (error) {
+      throw new BadRequestError110("Invalid patrol log ID format.");
+    }
+    const cacheKey = makeCacheKey34(namespace_collection, { _id });
+    const cachedData = await getCache(cacheKey);
+    if (cachedData) {
+      logger92.info(`Cache hit for key: ${cacheKey}`);
+      return cachedData;
+    }
+    try {
+      const data = await collection.findOne({ _id }, { session });
+      setCache(cacheKey, data, 15 * 60).then(() => {
+        logger92.info(`Cache set for key: ${cacheKey}`);
+      }).catch((err) => {
+        logger92.error(`Failed to set cache for key: ${cacheKey}`, err);
+      });
+      return data;
+    } catch (error) {
+      throw error;
+    }
+  }
   function delCachedData() {
     delNamespace().then(() => {
       logger92.log({
@@ -21226,7 +21390,8 @@ function usePatrolLogRepo() {
     add,
     getAll,
     updateById,
-    deleteById
+    deleteById,
+    getById
   };
 }
 
@@ -21303,7 +21468,8 @@ function usePatrolLogController() {
   const {
     getAll: _getAll,
     updateById: _updateById,
-    deleteById: _deleteById
+    deleteById: _deleteById,
+    getById: _getById
   } = usePatrolLogRepo();
   const { add: _add } = usePatrolLogService();
   async function add(req, res, next) {
@@ -21415,7 +21581,28 @@ function usePatrolLogController() {
       return;
     }
   }
-  return { add, getAll, updateById, deleteById };
+  async function getById(req, res, next) {
+    const id = req.params.id;
+    const validation = Joi66.object({
+      id: Joi66.string().hex().required()
+    });
+    const { error } = validation.validate({ id });
+    if (error) {
+      next(new BadRequestError112(error.message));
+      return;
+    }
+    try {
+      const logs = await _getById(id);
+      res.json({
+        message: "Successfully retrieved patrol log.",
+        data: logs
+      });
+      return;
+    } catch (error2) {
+      next(error2);
+    }
+  }
+  return { add, getAll, updateById, deleteById, getById };
 }
 
 // src/models/site-facility.model.ts
@@ -23948,7 +24135,7 @@ function useDocumentManagementController() {
   }
   async function deleteDocumentById(req, res, next) {
     const validation = Joi74.string().hex().required();
-    const _id = req.params.id;
+    const _id = req.query.id;
     const { error } = validation.validate(_id);
     if (error) {
       logger102.log({ level: "error", message: error.message });
@@ -27647,22 +27834,31 @@ function UseAccessManagementRepo() {
       throw new Error(error.message);
     }
   }
+  function getAfterSecondSlash(term) {
+    const first = term.indexOf("/");
+    if (first === -1)
+      return "";
+    const second = term.indexOf("/", first + 1);
+    if (second === -1)
+      return "";
+    return term.substring(second + 1).toLowerCase();
+  }
   function buildSearchQuery(search) {
     if (!search) {
       return {};
     }
     const terms = search.split("/").map((s) => s.trim()).filter(Boolean);
-    if (search.includes("/") && terms.length <= 3) {
-      switch (terms.length) {
-        case 3:
+    if (search.includes("/")) {
+      switch (true) {
+        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" }, terms[2].toLowerCase()] } }
+              { $expr: { $eq: [{ $toLower: "$level.units.name" }, getAfterSecondSlash(search)] } }
             ]
           };
-        case 2:
+        case terms.length === 2:
           return {
             $and: [
               { $expr: { $eq: [{ $toLower: "$name" }, terms[0].toLowerCase()] } },
@@ -27893,6 +28089,207 @@ function UseAccessManagementRepo() {
       throw new Error(error.message);
     }
   }
+  async function assignedAccessCardsRepo(params) {
+    try {
+      const site = new ObjectId83(params.site);
+      const userType = params.userType;
+      const type = params.type;
+      const search = params.search;
+      const query = {
+        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"
+                                }
+                              }
+                            }
+                          },
+                          {
+                            $project: {
+                              _id: 0,
+                              accessCardCount: {
+                                $size: "$cards"
+                              },
+                              accessLevels: 1,
+                              liftAccessLevels: 1,
+                              doorNames: 1,
+                              liftNames: 1
+                            }
+                          }
+                        ],
+                        as: "fAccessCards"
+                      }
+                    },
+                    {
+                      $match: {
+                        "fAccessCards.0": { $exists: true }
+                      }
+                    }
+                  ],
+                  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
+          }
+        }
+      ], { allowDiskUse: true }).toArray();
+      return result;
+    } catch (error) {
+      throw new Error(error.message);
+    }
+  }
+  async function acknowlegdeCardRepo(params) {
+    const session = useAtlas74.getClient()?.startSession();
+    try {
+      session?.startTransaction();
+      const { userId, cardId, site } = params;
+      const allUserId = await Promise.all(userId.map(async (id) => new ObjectId83(id)));
+      const allCardId = await Promise.all(cardId.map(async (id) => new ObjectId83(id)));
+      const siteId = new ObjectId83(site);
+      const result = await collection().updateMany(
+        {
+          $or: [
+            {
+              _id: { $in: allCardId },
+              site: siteId
+            },
+            {
+              userId: { $in: allUserId },
+              site: siteId,
+              isActivated: false,
+              replacementStatus: "Issuance"
+            }
+          ]
+        },
+        { $set: { replacementStatus: "Complete" } },
+        { session }
+      );
+      await session?.commitTransaction();
+      return result;
+    } catch (error) {
+      await session?.abortTransaction();
+      throw new Error(error.message);
+    } finally {
+      await session?.endSession();
+    }
+  }
   return {
     createIndexes,
     createIndexForEntrypass,
@@ -27901,7 +28298,9 @@ function UseAccessManagementRepo() {
     accessManagementSettingsRepo,
     allAccessCardsCountsRepo,
     availableAccessCardsRepo,
-    userTypeAccessCardsRepo
+    userTypeAccessCardsRepo,
+    assignedAccessCardsRepo,
+    acknowlegdeCardRepo
   };
 }
 
@@ -28006,6 +28405,8 @@ var formatAccessGroup = (data, search) => {
 
 // src/services/access-management.service.ts
 import { parseStringPromise } from "xml2js";
+import { useCache as useCache47 } from "@7365admin1/node-server-utils";
+var namespace = "cache:acm";
 function useAccessManagementSvc() {
   const {
     addPhysicalCardRepo,
@@ -28013,7 +28414,9 @@ function useAccessManagementSvc() {
     accessManagementSettingsRepo,
     allAccessCardsCountsRepo,
     availableAccessCardsRepo,
-    userTypeAccessCardsRepo
+    userTypeAccessCardsRepo,
+    assignedAccessCardsRepo,
+    acknowlegdeCardRepo
   } = UseAccessManagementRepo();
   const addPhysicalCardSvc = async (payload) => {
     try {
@@ -28031,12 +28434,34 @@ function useAccessManagementSvc() {
       throw new Error(err.message);
     }
   };
+  const setCache = async (params) => {
+    const { key, data, ttlSeconds = 60, redis } = params;
+    const jsonData = JSON.stringify(data);
+    await redis.set(key, jsonData, "EX", ttlSeconds);
+  };
+  const getCache = async (params) => {
+    const { key, redis } = params;
+    const result = await redis.get(key);
+    return result ? JSON.parse(result) : null;
+  };
   const doorAccessLevelsSvc = async (params) => {
     try {
+      const key = `${namespace}:${params.user}:door-levels`;
+      const listKey = `${namespace}:${params.user}:list`;
+      const { redis } = useCache47(key);
+      const cachedData = await getCache({ key, redis });
+      if (cachedData) {
+        console.log("\u26A1 Cache hit:", key);
+        redis.expire(key, 60).catch(console.error);
+        redis.lrem(listKey, 0, key).then(() => redis.lpush(listKey, key)).then(() => redis.ltrim(listKey, 0, 9)).catch(console.error);
+        return cachedData;
+      }
       const command = readTemplate("door-levels");
       const response = await sendCommand(command, params.acm_url);
       const res = await parseStringPromise(response, { explicitArray: false });
       const format = await formatDoorAccessLevels(res);
+      await setCache({ key, data: format, ttlSeconds: 60, redis });
+      redis.lrem(listKey, 0, key).then(() => redis.lpush(listKey, key)).then(() => redis.ltrim(listKey, 0, 9)).catch(console.error);
       return format;
     } catch (err) {
       throw new Error(err.message);
@@ -28044,10 +28469,22 @@ function useAccessManagementSvc() {
   };
   const liftAccessLevelsSvc = async (params) => {
     try {
+      const key = `${namespace}:${params.user}:lift-levels`;
+      const listKey = `${namespace}:${params.user}:list`;
+      const { redis } = useCache47(key);
+      const cachedData = await getCache({ key, redis });
+      if (cachedData) {
+        console.log("\u26A1 Cache hit:", key);
+        redis.expire(key, 60).catch(console.error);
+        redis.lrem(listKey, 0, key).then(() => redis.lpush(listKey, key)).then(() => redis.ltrim(listKey, 0, 9)).catch(console.error);
+        return cachedData;
+      }
       const command = readTemplate("lift-levels");
       const response = await sendCommand(command, params.acm_url);
       const res = await parseStringPromise(response, { explicitArray: false });
       const format = await formatLiftAccessLevels(res);
+      await setCache({ key, data: format, ttlSeconds: 60, redis });
+      redis.lrem(listKey, 0, key).then(() => redis.lpush(listKey, key)).then(() => redis.ltrim(listKey, 0, 9)).catch(console.error);
       return format;
     } catch (error) {
       throw new Error(error.message);
@@ -28055,10 +28492,22 @@ function useAccessManagementSvc() {
   };
   const accessGroupsSvc = async (params) => {
     try {
+      const key = `${namespace}:${params.user}:access-groups`;
+      const listKey = `${namespace}:${params.user}:list`;
+      const { redis } = useCache47(key);
+      const cachedData = await getCache({ key, redis });
+      if (cachedData) {
+        console.log("\u26A1 Cache hit:", key);
+        redis.expire(key, 60).catch(console.error);
+        redis.lrem(listKey, 0, key).then(() => redis.lpush(listKey, key)).then(() => redis.ltrim(listKey, 0, 9)).catch(console.error);
+        return cachedData;
+      }
       const command = readTemplate("access-group");
       const response = await sendCommand(command, params.acm_url);
       const res = await parseStringPromise(response, { explicitArray: false });
       const format = await formatAccessGroup(res);
+      await setCache({ key, data: format, ttlSeconds: 60, redis });
+      redis.lrem(listKey, 0, key).then(() => redis.lpush(listKey, key)).then(() => redis.ltrim(listKey, 0, 9)).catch(console.error);
       return format;
     } catch (err) {
       throw new Error(err.message);
@@ -28096,6 +28545,22 @@ function useAccessManagementSvc() {
       throw new Error(err.message);
     }
   };
+  const assignedAccessCardsSvc = async (params) => {
+    try {
+      const response = await assignedAccessCardsRepo({ ...params });
+      return response;
+    } catch (err) {
+      throw new Error(err.message);
+    }
+  };
+  const acknowlegdeCardSvc = async (params) => {
+    try {
+      const response = await acknowlegdeCardRepo({ ...params });
+      return response;
+    } catch (err) {
+      throw new Error(err.message);
+    }
+  };
   return {
     addPhysicalCardSvc,
     addNonPhysicalCardSvc,
@@ -28105,7 +28570,9 @@ function useAccessManagementSvc() {
     accessManagementSettingsSvc,
     allAccessCardsCountsSvc,
     availableAccessCardsSvc,
-    userTypeAccessCardsSvc
+    userTypeAccessCardsSvc,
+    assignedAccessCardsSvc,
+    acknowlegdeCardSvc
   };
 }
 
@@ -28120,7 +28587,9 @@ function useAccessManagementController() {
     accessManagementSettingsSvc,
     allAccessCardsCountsSvc,
     availableAccessCardsSvc,
-    userTypeAccessCardsSvc
+    userTypeAccessCardsSvc,
+    assignedAccessCardsSvc,
+    acknowlegdeCardSvc
   } = useAccessManagementSvc();
   const addPhysicalCard = async (req, res) => {
     try {
@@ -28251,10 +28720,11 @@ function useAccessManagementController() {
   const doorAccessLevels = async (req, res) => {
     try {
       const { acm_url } = req.query;
+      const user = req.cookies?.sid;
       if (!acm_url || typeof acm_url !== "string") {
         throw new Error("Access Control URL is required");
       }
-      const result = await doorAccessLevelsSvc({ acm_url });
+      const result = await doorAccessLevelsSvc({ acm_url, user });
       return res.status(200).json({ message: "Success", data: result });
     } catch (error) {
       return res.status(400).json({
@@ -28266,10 +28736,11 @@ function useAccessManagementController() {
   const liftAccessLevels = async (req, res) => {
     try {
       const { acm_url } = req.query;
+      const user = req.cookies?.sid;
       if (!acm_url || typeof acm_url !== "string") {
         throw new Error("Access Control URL is required");
       }
-      const result = await liftAccessLevelsSvc({ acm_url });
+      const result = await liftAccessLevelsSvc({ acm_url, user });
       return res.status(200).json({ message: "Success", data: result });
     } catch (error) {
       return res.status(400).json({
@@ -28281,10 +28752,11 @@ function useAccessManagementController() {
   const accessGroups = async (req, res) => {
     try {
       const { acm_url } = req.query;
+      const user = req.cookies?.sid;
       if (!acm_url || typeof acm_url !== "string") {
         throw new Error("Access Control URL is required");
       }
-      const result = await accessGroupsSvc({ acm_url });
+      const result = await accessGroupsSvc({ acm_url, user });
       return res.status(200).json({ message: "Success", data: result });
     } catch (error) {
       return res.status(400).json({
@@ -28377,6 +28849,49 @@ function useAccessManagementController() {
       });
     }
   };
+  const assignedAccessCards = async (req, res) => {
+    try {
+      const { site, userType, type, search = "" } = req.query;
+      const schema2 = Joi85.object({
+        site: Joi85.string().hex().required(),
+        userType: Joi85.string().required(),
+        type: Joi85.string().required(),
+        search: Joi85.string().optional().allow("", null)
+      });
+      const { error } = schema2.validate({ site, userType, type, search });
+      if (error) {
+        return res.status(400).json({ message: error.message });
+      }
+      const result = await assignedAccessCardsSvc({ site, userType, type, search });
+      return res.status(200).json({ message: "Success", data: result });
+    } catch (error) {
+      return res.status(500).json({
+        data: null,
+        message: error.message
+      });
+    }
+  };
+  const acknowlegdeCard = async (req, res) => {
+    try {
+      const { userId, site, cardId } = req.body;
+      const schema2 = Joi85.object({
+        userId: Joi85.array().items(Joi85.string().hex()).required(),
+        cardId: Joi85.array().items(Joi85.string().hex()).required(),
+        site: Joi85.string().hex().required()
+      });
+      const { error } = schema2.validate({ userId, cardId, site });
+      if (error) {
+        return res.status(400).json({ message: error.message });
+      }
+      const result = await acknowlegdeCardSvc({ userId, cardId, site });
+      return res.status(200).json({ message: "Success", data: result });
+    } catch (error) {
+      return res.status(500).json({
+        data: null,
+        message: error.message
+      });
+    }
+  };
   return {
     addPhysicalCard,
     addNonPhysicalCard,
@@ -28386,7 +28901,9 @@ function useAccessManagementController() {
     accessManagementSettings,
     allAccessCardsCounts,
     availableAccessCards,
-    userTypeAccessCards
+    userTypeAccessCards,
+    assignedAccessCards,
+    acknowlegdeCard
   };
 }
 
@@ -28456,7 +28973,7 @@ import {
   makeCacheKey as makeCacheKey45,
   paginate as paginate39,
   useAtlas as useAtlas75,
-  useCache as useCache47
+  useCache as useCache48
 } from "@7365admin1/node-server-utils";
 import { ObjectId as ObjectId85 } from "mongodb";
 function useNfcPatrolTagRepo() {
@@ -28467,8 +28984,8 @@ function useNfcPatrolTagRepo() {
   const namespace_collection = "nfc-patrol-tags";
   const namespace_collection_nfc_patrol_routes = "nfc-patrol-routes";
   const collection = db.collection(namespace_collection);
-  const { delNamespace, getCache, setCache } = useCache47(namespace_collection);
-  const { delNamespace: delNamespaceNfcPatrolRoutes } = useCache47(
+  const { delNamespace, getCache, setCache } = useCache48(namespace_collection);
+  const { delNamespace: delNamespaceNfcPatrolRoutes } = useCache48(
     namespace_collection_nfc_patrol_routes
   );
   async function createIndexes() {
@@ -28915,7 +29432,7 @@ import {
   NotFoundError as NotFoundError37,
   paginate as paginate40,
   useAtlas as useAtlas77,
-  useCache as useCache48
+  useCache as useCache49
 } from "@7365admin1/node-server-utils";
 import { ObjectId as ObjectId87 } from "mongodb";
 function useOccurrenceBookRepo() {
@@ -28947,7 +29464,7 @@ function useOccurrenceBookRepo() {
   }
   const namespace_collection = "occurrence-books";
   const collection = db.collection(namespace_collection);
-  const { delNamespace, getCache, setCache } = useCache48(namespace_collection);
+  const { delNamespace, getCache, setCache } = useCache49(namespace_collection);
   async function add(value, session) {
     try {
       value = MOccurrenceBook(value);
@@ -29525,7 +30042,7 @@ import {
   NotFoundError as NotFoundError38,
   paginate as paginate41,
   useAtlas as useAtlas79,
-  useCache as useCache49
+  useCache as useCache50
 } from "@7365admin1/node-server-utils";
 import { ObjectId as ObjectId89 } from "mongodb";
 function useBulletinVideoRepo() {
@@ -29544,7 +30061,7 @@ function useBulletinVideoRepo() {
   }
   const namespace_collection = "bulletin-videos";
   const collection = db.collection(namespace_collection);
-  const { delNamespace, getCache, setCache } = useCache49(namespace_collection);
+  const { delNamespace, getCache, setCache } = useCache50(namespace_collection);
   async function add(value, session) {
     try {
       value = MBulletinVideo(value);
@@ -30076,7 +30593,7 @@ import {
   InternalServerError as InternalServerError51,
   logger as logger127,
   useAtlas as useAtlas81,
-  useCache as useCache50,
+  useCache as useCache51,
   paginate as paginate42,
   makeCacheKey as makeCacheKey48
 } from "@7365admin1/node-server-utils";
@@ -30088,7 +30605,7 @@ function useStatementOfAccountRepo() {
   }
   const namespace_collection = "site.statement-of-accounts";
   const collection = db.collection(namespace_collection);
-  const { delNamespace, getCache, setCache } = useCache50(namespace_collection);
+  const { delNamespace, getCache, setCache } = useCache51(namespace_collection);
   async function createTextIndex() {
     try {
       await collection.createIndex({
@@ -30851,7 +31368,7 @@ import {
   NotFoundError as NotFoundError40,
   paginate as paginate43,
   useAtlas as useAtlas83,
-  useCache as useCache51
+  useCache as useCache52
 } from "@7365admin1/node-server-utils";
 import { ObjectId as ObjectId93 } from "mongodb";
 function useEntryPassSettingsRepo() {
@@ -30861,7 +31378,7 @@ function useEntryPassSettingsRepo() {
   }
   const namespace_collection = "site.entrypass-settings";
   const collection = db.collection(namespace_collection);
-  const { delNamespace, getCache, setCache } = useCache51(namespace_collection);
+  const { delNamespace, getCache, setCache } = useCache52(namespace_collection);
   async function createTextIndex() {
     try {
       await collection.createIndex({
@@ -31423,7 +31940,7 @@ import {
   logger as logger133,
   makeCacheKey as makeCacheKey50,
   useAtlas as useAtlas84,
-  useCache as useCache52
+  useCache as useCache53
 } from "@7365admin1/node-server-utils";
 function useDashboardRepo() {
   const db = useAtlas84.getDb();
@@ -31434,7 +31951,7 @@ function useDashboardRepo() {
   const work_order_collection = db.collection("work-orders");
   const visitor_collection = db.collection("visitor.transactions");
   const namespace_collection = "dashboard";
-  const { delNamespace, getCache, setCache } = useCache52(namespace_collection);
+  const { delNamespace, getCache, setCache } = useCache53(namespace_collection);
   async function getAll({
     site = ""
   }, session) {
@@ -31598,7 +32115,7 @@ import {
   makeCacheKey as makeCacheKey51,
   paginate as paginate44,
   useAtlas as useAtlas85,
-  useCache as useCache53
+  useCache as useCache54
 } from "@7365admin1/node-server-utils";
 import { ObjectId as ObjectId95 } from "mongodb";
 function useNfcPatrolRouteRepo() {
@@ -31608,7 +32125,7 @@ function useNfcPatrolRouteRepo() {
   }
   const namespace_collection = "nfc-patrol-routes";
   const collection = db.collection(namespace_collection);
-  const { delNamespace, getCache, setCache } = useCache53(namespace_collection);
+  const { delNamespace, getCache, setCache } = useCache54(namespace_collection);
   async function createIndexes() {
     try {
       await collection.createIndexes([
@@ -32345,7 +32862,7 @@ import {
   NotFoundError as NotFoundError43,
   paginate as paginate45,
   useAtlas as useAtlas87,
-  useCache as useCache54
+  useCache as useCache55
 } from "@7365admin1/node-server-utils";
 import { ObjectId as ObjectId97 } from "mongodb";
 function useIncidentReportRepo() {
@@ -32376,7 +32893,7 @@ function useIncidentReportRepo() {
   }
   const namespace_collection = "incident-reports";
   const collection = db.collection(namespace_collection);
-  const { delNamespace, getCache, setCache } = useCache54(namespace_collection);
+  const { delNamespace, getCache, setCache } = useCache55(namespace_collection);
   async function add(value, session) {
     try {
       value = MIncidentReport(value);
@@ -33117,7 +33634,7 @@ import {
   makeCacheKey as makeCacheKey53,
   NotFoundError as NotFoundError45,
   useAtlas as useAtlas89,
-  useCache as useCache55
+  useCache as useCache56
 } from "@7365admin1/node-server-utils";
 import { ObjectId as ObjectId99 } from "mongodb";
 function useNfcPatrolSettingsRepository() {
@@ -33127,7 +33644,7 @@ function useNfcPatrolSettingsRepository() {
   }
   const namespace_collection = "site.nfc-patrol-settings";
   const collection = db.collection(namespace_collection);
-  const { delNamespace, setCache, getCache } = useCache55(namespace_collection);
+  const { delNamespace, setCache, getCache } = useCache56(namespace_collection);
   async function createIndexes() {
     try {
       await collection.createIndexes([{ key: { site: 1 }, unique: true }]);
@@ -33372,7 +33889,7 @@ import {
   NotFoundError as NotFoundError46,
   paginate as paginate46,
   useAtlas as useAtlas91,
-  useCache as useCache56
+  useCache as useCache57
 } from "@7365admin1/node-server-utils";
 
 // src/models/occurrence-subject.model.ts
@@ -33449,7 +33966,7 @@ function useOccurrenceSubjectRepo() {
   }
   const namespace_collection = "occurrence-subjects";
   const collection = db.collection(namespace_collection);
-  const { delNamespace, getCache, setCache } = useCache56(namespace_collection);
+  const { delNamespace, getCache, setCache } = useCache57(namespace_collection);
   async function add(value, session) {
     try {
       value = MOccurrenceSubject(value);
@@ -34017,7 +34534,7 @@ import {
   NotFoundError as NotFoundError47,
   paginate as paginate47,
   useAtlas as useAtlas93,
-  useCache as useCache57
+  useCache as useCache58
 } from "@7365admin1/node-server-utils";
 import { ObjectId as ObjectId103 } from "mongodb";
 function useOnlineFormRepo() {
@@ -34027,7 +34544,7 @@ function useOnlineFormRepo() {
   }
   const namespace_collection = "online-forms";
   const collection = db.collection(namespace_collection);
-  const { delNamespace, getCache, setCache } = useCache57(namespace_collection);
+  const { delNamespace, getCache, setCache } = useCache58(namespace_collection);
   async function createTextIndex() {
     try {
       await collection.createIndex({
@@ -34763,7 +35280,7 @@ import {
   makeCacheKey as makeCacheKey56,
   paginate as paginate48,
   useAtlas as useAtlas95,
-  useCache as useCache58
+  useCache as useCache59
 } from "@7365admin1/node-server-utils";
 import { ObjectId as ObjectId105 } from "mongodb";
 function useNfcPatrolLogRepo() {
@@ -34773,7 +35290,7 @@ function useNfcPatrolLogRepo() {
   }
   const namespace_collection = "nfc-patrol-logs";
   const collection = db.collection(namespace_collection);
-  const { delNamespace, getCache, setCache } = useCache58(namespace_collection);
+  const { delNamespace, getCache, setCache } = useCache59(namespace_collection);
   async function createIndexes() {
     try {
       await collection.createIndexes([