@7365admin1/core 2.9.0 → 2.11.0

package/dist/index.mjs

@@ -372,7 +372,8 @@ function useFeedbackRepo() {
       query.$or = [
         { subject: { $regex: search, $options: "i" } },
         { description: { $regex: search, $options: "i" } },
-        { createdByName: { $regex: search, $options: "i" } }
+        { createdByName: { $regex: search, $options: "i" } },
+        { category: { $regex: search, $options: "i" } }
       ];
       cacheOptions.search = search;
     }
@@ -933,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);
@@ -945,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;
@@ -993,7 +1000,9 @@ function useWorkOrderRepo() {
     if (search) {
       query.$or = [
         { subject: { $regex: search, $options: "i" } },
-        { createdByName: { $regex: search, $options: "i" } }
+        { createdByName: { $regex: search, $options: "i" } },
+        { description: { $regex: search, $options: "i" } },
+        { category: { $regex: search, $options: "i" } }
       ];
       cacheOptions.search = search;
     }
@@ -1179,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) {
@@ -1206,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 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) {
@@ -1228,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) {
@@ -1262,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) {
@@ -1293,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 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) {
@@ -2855,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,
@@ -2862,7 +2914,8 @@ function useVerificationRepo() {
     getById,
     getVerifications,
     getByIdByType,
-    updateStatusById
+    updateStatusById,
+    getByStatus
   };
 }
 
@@ -3226,7 +3279,8 @@ var allowedFieldsSite = [
   "metadata.block",
   "metadata.guardPosts",
   "metadata.gracePeriod",
-  "metadata.incidentCounter"
+  "metadata.incidentCounter",
+  "metadata.incidentLogo"
 ];
 var siteSchema = Joi8.object({
   name: Joi8.string().required(),
@@ -4115,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();
@@ -4361,7 +4416,6 @@ function useVerificationService() {
   }
   async function cancelUserInvitation(id) {
     try {
-      await verify(id);
       await updateStatusById(id, "cancelled");
     } catch (error) {
       throw new InternalServerError11(
@@ -4423,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,
@@ -4431,7 +4509,8 @@ function useVerificationService() {
     verify,
     cancelUserInvitation,
     updateStatusById,
-    signUp
+    signUp,
+    checkExpiredInvitation
   };
 }
 
@@ -5641,6 +5720,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);
@@ -5769,7 +5858,8 @@ function useFileRepo() {
     deleteFileById,
     getAllDraftedFiles,
     updateStatusById,
-    getFileById
+    getFileById,
+    createIndex
   };
 }
 
@@ -10802,7 +10892,8 @@ function useFeedbackController() {
   }
   async function deleteFeedback(req, res, next) {
     const validation = Joi28.string().hex().required();
-    const _id = req.params.id;
+    const _id = req.query.id;
+    console.log(_id);
     const { error } = validation.validate(_id);
     if (error) {
       logger39.log({ level: "error", message: error.message });
@@ -11166,7 +11257,8 @@ function useWorkOrderController() {
   }
   async function deleteWorkOrder(req, res, next) {
     const validation = Joi29.string().hex().required();
-    const _id = req.params.id;
+    const _id = req.query.id;
+    console.log(_id);
     const { error } = validation.validate(_id);
     if (error) {
       logger40.log({ level: "error", message: error.message });
@@ -12706,7 +12798,7 @@ function useSiteController() {
     const validation = Joi36.object({
       _id: Joi36.string().hex().required(),
       field: Joi36.string().valid(...allowedFieldsSite).required(),
-      value: Joi36.number().integer().min(0).required()
+      value: Joi36.alternatives().try(Joi36.number().integer().min(0), Joi36.string().hex().length(24)).required()
     });
     const _id = req.params.id ?? "";
     const field = req.body.field ?? "";
@@ -27207,11 +27299,11 @@ var EAccessCardTypes = /* @__PURE__ */ ((EAccessCardTypes2) => {
   EAccessCardTypes2["QR"] = "QRCODE";
   return EAccessCardTypes2;
 })(EAccessCardTypes || {});
-var EAccessCardUserTypes = /* @__PURE__ */ ((EAccessCardUserTypes2) => {
-  EAccessCardUserTypes2["RESIDENT"] = "Resident/Tenant";
-  EAccessCardUserTypes2["CONTRACTOR"] = "Contractor";
-  EAccessCardUserTypes2["VISITOR"] = "Visitor";
-  return EAccessCardUserTypes2;
+var EAccessCardUserTypes = /* @__PURE__ */ ((EAccessCardUserTypes4) => {
+  EAccessCardUserTypes4["RESIDENT"] = "Resident/Tenant";
+  EAccessCardUserTypes4["CONTRACTOR"] = "Contractor";
+  EAccessCardUserTypes4["VISITOR"] = "Visitor";
+  return EAccessCardUserTypes4;
 })(EAccessCardUserTypes || {});
 var AccessTypeProps = /* @__PURE__ */ ((AccessTypeProps2) => {
   AccessTypeProps2["NORMAL"] = "Normal";
@@ -27273,7 +27365,8 @@ var MAccessCard = class {
     doorName,
     liftName,
     replacementStatus,
-    vmsRemarks
+    vmsRemarks,
+    isWinsland = false
   } = {}) {
     this._id = _id;
     this.userId = userId;
@@ -27300,12 +27393,14 @@ var MAccessCard = class {
     this.liftName = liftName;
     this.replacementStatus = replacementStatus;
     this.vmsRemarks = vmsRemarks;
+    this.isWinsland = isWinsland;
   }
 };
 
 // src/repositories/access-management.repo.ts
 import {
   InternalServerError as InternalServerError47,
+  paginate as paginate38,
   useAtlas as useAtlas74
 } from "@7365admin1/node-server-utils";
 import { ObjectId as ObjectId83 } from "mongodb";
@@ -27352,6 +27447,15 @@ function UseAccessManagementRepo() {
       return Promise.reject("Failed to create Access cards indexes.");
     }
   }
+  async function createIndexForEntrypass() {
+    try {
+      const entrypass = collectionName("entrypass-settings");
+      await Promise.all([entrypass.createIndex({ site: 1 })]);
+      return Promise.resolve("Access cards indexes created.");
+    } catch (error) {
+      return Promise.reject("Failed to create Access cards indexes.");
+    }
+  }
   async function addPhysicalCardRepo({
     payload
   }) {
@@ -27442,7 +27546,8 @@ function UseAccessManagementRepo() {
                 liftName: params.liftName,
                 assignedUnit: new ObjectId83(units[i]),
                 createdAt: new Date(params.createdAt),
-                updatedAt: new Date(params.updatedAt)
+                updatedAt: new Date(params.updatedAt),
+                isWinsland: params.isWinsland
               });
               try {
                 const result = await collection().insertOne(newCard);
@@ -27494,7 +27599,8 @@ function UseAccessManagementRepo() {
               liftName: params.liftName,
               assignedUnit: null,
               createdAt: new Date(params.createdAt),
-              updatedAt: new Date(params.updatedAt)
+              updatedAt: new Date(params.updatedAt),
+              isWinsland: params.isWinsland
             });
             try {
               const result = await collection().insertOne(newCard);
@@ -27526,10 +27632,538 @@ function UseAccessManagementRepo() {
       throw new Error(error.message);
     }
   }
+  async function accessManagementSettingsRepo(params) {
+    try {
+      params.site = new ObjectId83(params.site);
+      const result = collectionName("entrypass-settings").updateOne(
+        { site: params.site },
+        {
+          $set: {
+            ...params,
+            updatedAt: /* @__PURE__ */ new Date()
+          },
+          $setOnInsert: {
+            createdAt: /* @__PURE__ */ new Date()
+          }
+        },
+        { upsert: true }
+      );
+      await createIndexForEntrypass();
+      return result;
+    } catch (error) {
+      throw new Error(error.message);
+    }
+  }
+  async function allAccessCardsCountsRepo(params) {
+    try {
+      const site = new ObjectId83(params.site);
+      const userType = params.userType;
+      const result = await collection().aggregate([
+        {
+          $match: { site, userType }
+        },
+        {
+          $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" }]
+          }
+        }
+      ]).toArray();
+      const totalCardCount = {
+        available_physical: result[0].available_physical[0] ? result[0].available_physical[0].count : 0,
+        available_non_physical: result[0].available_non_physical[0] ? result[0].available_non_physical[0].count : 0,
+        assigned_physical: result[0].assigned_physical[0] ? result[0].assigned_physical[0].count : 0,
+        assigned_non_physical: result[0].assigned_non_physical[0] ? result[0].assigned_non_physical[0].count : 0
+      };
+      return totalCardCount;
+    } catch (error) {
+      throw new Error(error.message);
+    }
+  }
+  async function availableAccessCardsRepo(params) {
+    try {
+      const site = new ObjectId83(params.site);
+      const userType = params.userType;
+      const type = params.type;
+      const query = {
+        site: { $in: [site] },
+        userType,
+        assignedUnit: null,
+        type,
+        isActivated: true
+      };
+      const result = await collection().aggregate([
+        {
+          $match: { ...query }
+        },
+        {
+          $project: {
+            accessLevel: 1,
+            liftAccessLevel: 1,
+            doorName: 1,
+            liftName: 1
+          }
+        },
+        {
+          $group: {
+            _id: {
+              accessLevel: "$accessLevel",
+              liftAccessLevel: "$liftAccessLevel",
+              doorName: "$doorName",
+              liftName: "$liftName"
+            },
+            count: { $sum: 1 }
+          }
+        },
+        {
+          $project: {
+            _id: 0,
+            accessLevel: "$_id.accessLevel",
+            liftAccessLevel: "$_id.liftAccessLevel",
+            doorName: "$_id.doorName",
+            liftName: "$_id.liftName",
+            count: 1
+          }
+        }
+      ]).toArray();
+      return result;
+    } catch (error) {
+      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("/")) {
+      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" }, getAfterSecondSlash(search)] } }
+            ]
+          };
+        case terms.length === 2:
+          return {
+            $and: [
+              { $expr: { $eq: [{ $toLower: "$name" }, terms[0].toLowerCase()] } },
+              { $expr: { $eq: [{ $toLower: "$level.level" }, terms[1].toLowerCase()] } }
+            ]
+          };
+        default:
+          return {
+            $expr: { $eq: [{ $toLower: "$name" }, terms[0].toLowerCase()] }
+          };
+      }
+    }
+    return {
+      $or: [
+        { name: { $regex: search.trim(), $options: "i" } },
+        { "level.level": { $regex: search.trim(), $options: "i" } },
+        { "level.units.name": { $regex: search.trim(), $options: "i" } }
+      ]
+    };
+  }
+  async function userTypeAccessCardsRepo(params) {
+    try {
+      const site = new ObjectId83(params.site);
+      const userType = params.userType;
+      const page = params.page ? Number(params.page) - 1 : 0;
+      const limit = Number(params.limit) || 10;
+      const search = params.search;
+      const defaultQuery = {
+        site
+      };
+      const searchQuery = buildSearchQuery(search);
+      const result = await collectionName("buildings").aggregate([
+        // ✅ Match early with index-friendly query
+        {
+          $match: {
+            ...defaultQuery,
+            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 } }
+                  ],
+                  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
+              { $sort: { _id: -1 } },
+              { $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 } }
+                  ],
+                  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: { $ne: ["$$card.userId", 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" },
+                  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: {
+                    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 */] } } } }
+                    }
+                  },
+                  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 */] } } } }
+                    ]
+                  }
+                }
+              }
+            ]
+          }
+        }
+      ], { allowDiskUse: true }).toArray();
+      const totalCount = result[0]?.totalCount?.[0]?.count ?? 0;
+      const items = result[0]?.items ?? [];
+      const paginatedResult = paginate38(items, page, limit, totalCount);
+      return paginatedResult;
+    } catch (error) {
+      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);
+    }
+  }
   return {
     createIndexes,
+    createIndexForEntrypass,
     addPhysicalCardRepo,
-    addNonPhysicalCardRepo
+    addNonPhysicalCardRepo,
+    accessManagementSettingsRepo,
+    allAccessCardsCountsRepo,
+    availableAccessCardsRepo,
+    userTypeAccessCardsRepo,
+    assignedAccessCardsRepo
   };
 }
 
@@ -27634,8 +28268,18 @@ 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, addNonPhysicalCardRepo } = UseAccessManagementRepo();
+  const {
+    addPhysicalCardRepo,
+    addNonPhysicalCardRepo,
+    accessManagementSettingsRepo,
+    allAccessCardsCountsRepo,
+    availableAccessCardsRepo,
+    userTypeAccessCardsRepo,
+    assignedAccessCardsRepo
+  } = UseAccessManagementRepo();
   const addPhysicalCardSvc = async (payload) => {
     try {
       const response = await addPhysicalCardRepo({ payload });
@@ -27652,12 +28296,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);
@@ -27665,10 +28331,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);
@@ -27682,7 +28360,47 @@ function useAccessManagementSvc() {
       const format = await formatAccessGroup(res);
       return format;
     } catch (err) {
-      console.error("Failed to connect:", err);
+      throw new Error(err.message);
+    }
+  };
+  const accessManagementSettingsSvc = async (settings) => {
+    try {
+      const response = await accessManagementSettingsRepo({ ...settings });
+      return response;
+    } catch (err) {
+      throw new Error(err.message);
+    }
+  };
+  const allAccessCardsCountsSvc = async (params) => {
+    try {
+      const response = await allAccessCardsCountsRepo({ ...params });
+      return response;
+    } catch (err) {
+      throw new Error(err.message);
+    }
+  };
+  const availableAccessCardsSvc = async (params) => {
+    try {
+      const response = await availableAccessCardsRepo({ ...params });
+      return response;
+    } catch (err) {
+      throw new Error(err.message);
+    }
+  };
+  const userTypeAccessCardsSvc = async (params) => {
+    try {
+      const response = await userTypeAccessCardsRepo({ ...params });
+      return response;
+    } catch (err) {
+      throw new Error(err.message);
+    }
+  };
+  const assignedAccessCardsSvc = async (params) => {
+    try {
+      const response = await assignedAccessCardsRepo({ ...params });
+      return response;
+    } catch (err) {
+      throw new Error(err.message);
     }
   };
   return {
@@ -27690,7 +28408,12 @@ function useAccessManagementSvc() {
     addNonPhysicalCardSvc,
     doorAccessLevelsSvc,
     liftAccessLevelsSvc,
-    accessGroupsSvc
+    accessGroupsSvc,
+    accessManagementSettingsSvc,
+    allAccessCardsCountsSvc,
+    availableAccessCardsSvc,
+    userTypeAccessCardsSvc,
+    assignedAccessCardsSvc
   };
 }
 
@@ -27701,7 +28424,12 @@ function useAccessManagementController() {
     addNonPhysicalCardSvc,
     doorAccessLevelsSvc,
     liftAccessLevelsSvc,
-    accessGroupsSvc
+    accessGroupsSvc,
+    accessManagementSettingsSvc,
+    allAccessCardsCountsSvc,
+    availableAccessCardsSvc,
+    userTypeAccessCardsSvc,
+    assignedAccessCardsSvc
   } = useAccessManagementSvc();
   const addPhysicalCard = async (req, res) => {
     try {
@@ -27761,7 +28489,8 @@ function useAccessManagementController() {
         createdAt,
         updatedAt,
         startDate,
-        endDate
+        endDate,
+        isWinsland
       } = req.body;
       const schema2 = Joi85.object({
         site: Joi85.string().hex().required(),
@@ -27777,7 +28506,8 @@ function useAccessManagementController() {
         startDate: Joi85.date().required(),
         endDate: Joi85.date().required(),
         createdAt: Joi85.date().required(),
-        updatedAt: Joi85.date().required()
+        updatedAt: Joi85.date().required(),
+        isWinsland: Joi85.boolean().optional().allow(null)
       });
       const { error } = schema2.validate({
         site,
@@ -27793,7 +28523,8 @@ function useAccessManagementController() {
         startDate,
         endDate,
         createdAt,
-        updatedAt
+        updatedAt,
+        isWinsland
       });
       if (error) {
         throw new Error(`${error.message}`);
@@ -27812,7 +28543,8 @@ function useAccessManagementController() {
         startDate,
         endDate,
         createdAt,
-        updatedAt
+        updatedAt,
+        isWinsland
       });
       return res.status(201).json({
         data: result,
@@ -27828,10 +28560,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({
@@ -27843,10 +28576,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({
@@ -27870,12 +28604,123 @@ function useAccessManagementController() {
       });
     }
   };
+  const accessManagementSettings = async (req, res) => {
+    try {
+      const settings = req.body;
+      const result = await accessManagementSettingsSvc(settings);
+      return res.status(201).json({ message: "Success", data: result });
+    } catch (error) {
+      return res.status(400).json({
+        data: null,
+        message: error.message
+      });
+    }
+  };
+  const allAccessCardsCounts = async (req, res) => {
+    try {
+      const { site, userType } = req.query;
+      const schema2 = Joi85.object({
+        site: Joi85.string().hex().required(),
+        userType: Joi85.string().required()
+      });
+      const { error } = schema2.validate({ site, userType });
+      if (error) {
+        throw new Error(`${error.message}`);
+      }
+      const result = await allAccessCardsCountsSvc({ site, userType });
+      return res.status(200).json({ message: "Success", data: result });
+    } catch (error) {
+      return res.status(400).json({
+        data: null,
+        message: error.message
+      });
+    }
+  };
+  const availableAccessCards = async (req, res) => {
+    try {
+      const { site, userType, type } = req.query;
+      const schema2 = Joi85.object({
+        site: Joi85.string().hex().required(),
+        userType: Joi85.string().optional().allow("", null),
+        type: Joi85.string().optional().allow("", null)
+      });
+      const { error } = schema2.validate({ site, userType, type });
+      if (error) {
+        return res.status(400).json({ message: error.message });
+      }
+      const result = await availableAccessCardsSvc({ site, userType, type });
+      return res.status(200).json({ message: "Success", data: result });
+    } catch (error) {
+      return res.status(400).json({
+        data: null,
+        message: error.message
+      });
+    }
+  };
+  const userTypeAccessCards = async (req, res) => {
+    try {
+      const {
+        page = 1,
+        limit = 10,
+        search = "",
+        site,
+        organization,
+        userType
+      } = req.query;
+      const schema2 = Joi85.object({
+        page: Joi85.number().required(),
+        limit: Joi85.number().optional().default(10),
+        site: Joi85.string().hex().required(),
+        organization: Joi85.string().hex().optional().allow("", null),
+        search: Joi85.string().optional().allow("", null),
+        userType: Joi85.string().required()
+      });
+      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 });
+      return res.status(200).json({ message: "Success", data: result });
+    } catch (error) {
+      return res.status(500).json({
+        data: null,
+        message: error.message
+      });
+    }
+  };
+  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
+      });
+    }
+  };
   return {
     addPhysicalCard,
     addNonPhysicalCard,
     doorAccessLevels,
     liftAccessLevels,
-    accessGroups
+    accessGroups,
+    accessManagementSettings,
+    allAccessCardsCounts,
+    availableAccessCards,
+    userTypeAccessCards,
+    assignedAccessCards
   };
 }
 
@@ -27945,7 +28790,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() {
@@ -27956,8 +28801,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() {
@@ -28404,7 +29249,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() {
@@ -28436,7 +29281,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);
@@ -29014,7 +29859,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() {
@@ -29033,7 +29878,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);
@@ -29565,7 +30410,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";
@@ -29577,7 +30422,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({
@@ -30340,7 +31185,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() {
@@ -30350,7 +31195,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({
@@ -30912,7 +31757,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();
@@ -30923,7 +31768,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) {
@@ -31087,7 +31932,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() {
@@ -31097,7 +31942,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([
@@ -31819,7 +32664,11 @@ function MIncidentReport(value) {
 }
 
 // src/services/incident-report.service.ts
-import { useAtlas as useAtlas88, BadRequestError as BadRequestError160 } from "@7365admin1/node-server-utils";
+import {
+  useAtlas as useAtlas88,
+  BadRequestError as BadRequestError160,
+  NotFoundError as NotFoundError44
+} from "@7365admin1/node-server-utils";
 
 // src/repositories/incident-report.repo.ts
 import {
@@ -31830,7 +32679,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() {
@@ -31861,7 +32710,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);
@@ -32151,15 +33000,18 @@ function useIncidentReportService() {
   const {
     add: _add,
     updateIncidentReportById: _updateIncidentReportById,
-    reviewIncidentReport: _reviewIncidentReport
+    reviewIncidentReport: _reviewIncidentReport,
+    getIncidentReportById: _getIncidentReportById
   } = useIncidentReportRepo();
   const {
     updateSiteIncidentCounter: _updateSiteIncidentCounter,
     getSiteById: _getSiteById
   } = useSiteRepo();
+  const { updateStatusById } = useFileRepo();
   const { getUserById } = useUserRepo();
   const { getById: _getUnitById } = useBuildingUnitRepo();
   const { getById: _getOrganizationById } = useOrgRepo();
+  const { deleteFile } = useFileService();
   async function add(value) {
     const session = useAtlas88.getClient()?.startSession();
     session?.startTransaction();
@@ -32177,6 +33029,19 @@ function useIncidentReportService() {
           );
         }
       }
+      const incidentAttachments = value?.photos ?? [];
+      if (incidentAttachments.length > 0) {
+        for (const attachment of incidentAttachments) {
+          const file = await updateStatusById(
+            attachment,
+            { status: "active" },
+            session
+          );
+          if (!file) {
+            throw new NotFoundError44("File not found.");
+          }
+        }
+      }
       const result = await _add(value, session);
       await session?.commitTransaction();
       return result;
@@ -32191,6 +33056,26 @@ function useIncidentReportService() {
     const session = useAtlas88.getClient()?.startSession();
     session?.startTransaction();
     try {
+      const incidentReport = await _getIncidentReportById(id);
+      const dataAttchments = value?.photos || [];
+      const incidentAttachments = incidentReport?.photos || [];
+      const deletedFiles = [];
+      incidentAttachments.forEach((id2) => {
+        if (!dataAttchments.includes(id2)) {
+          deletedFiles.push(id2);
+        }
+      });
+      if (deletedFiles.length > 0) {
+        await Promise.all(
+          deletedFiles.map(async (id2) => {
+            try {
+              await deleteFile(id2);
+            } catch (error) {
+              throw error;
+            }
+          })
+        );
+      }
       await _updateIncidentReportById(id, value, session);
       await session?.commitTransaction();
       return "Successfully updated incident report.";
@@ -32564,9 +33449,9 @@ import {
   InternalServerError as InternalServerError56,
   logger as logger142,
   makeCacheKey as makeCacheKey53,
-  NotFoundError as NotFoundError44,
+  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() {
@@ -32576,7 +33461,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 }]);
@@ -32654,7 +33539,7 @@ function useNfcPatrolSettingsRepository() {
         { session }
       );
       if (res.matchedCount === 0) {
-        throw new NotFoundError44("NFC patrol settings not found for this site.");
+        throw new NotFoundError45("NFC patrol settings not found for this site.");
       }
       delNamespace().then(() => {
         logger142.info(`Cache cleared for namespace: ${namespace_collection}`);
@@ -32818,10 +33703,10 @@ import {
   InternalServerError as InternalServerError57,
   logger as logger145,
   makeCacheKey as makeCacheKey54,
-  NotFoundError as NotFoundError45,
+  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
@@ -32898,7 +33783,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);
@@ -33037,7 +33922,7 @@ function useOccurrenceSubjectRepo() {
     try {
       const data = await collection.findOne({ _id }, { session });
       if (!data) {
-        throw new NotFoundError45("Occurrence subject not found.");
+        throw new NotFoundError46("Occurrence subject not found.");
       }
       setCache(cacheKey, data, 15 * 60).then(() => {
         logger145.info(`Cache set for key: ${cacheKey}`);
@@ -33463,10 +34348,10 @@ import {
   InternalServerError as InternalServerError58,
   logger as logger147,
   makeCacheKey as makeCacheKey55,
-  NotFoundError as NotFoundError46,
+  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() {
@@ -33476,7 +34361,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({
@@ -33599,7 +34484,7 @@ function useOnlineFormRepo() {
         }
       ]).toArray();
       if (!data || !data.length) {
-        throw new NotFoundError46("Document not found.");
+        throw new NotFoundError47("Document not found.");
       }
       setCache(cacheKey, data[0], 15 * 60).then(() => {
         logger147.info(`Cache set for key: ${cacheKey}`);
@@ -34212,7 +35097,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() {
@@ -34222,7 +35107,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([