@7365admin1/core 2.9.0 → 2.10.0

package/dist/index.js

@@ -671,7 +671,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;
     }
@@ -1283,7 +1284,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;
     }
@@ -3473,7 +3476,8 @@ var allowedFieldsSite = [
   "metadata.block",
   "metadata.guardPosts",
   "metadata.gracePeriod",
-  "metadata.incidentCounter"
+  "metadata.incidentCounter",
+  "metadata.incidentLogo"
 ];
 var siteSchema = import_joi8.default.object({
   name: import_joi8.default.string().required(),
@@ -10931,7 +10935,8 @@ function useFeedbackController() {
   }
   async function deleteFeedback(req, res, next) {
     const validation = import_joi28.default.string().hex().required();
-    const _id = req.params.id;
+    const _id = req.query.id;
+    console.log(_id);
     const { error } = validation.validate(_id);
     if (error) {
       import_node_server_utils55.logger.log({ level: "error", message: error.message });
@@ -11295,7 +11300,8 @@ function useWorkOrderController() {
   }
   async function deleteWorkOrder(req, res, next) {
     const validation = import_joi29.default.string().hex().required();
-    const _id = req.params.id;
+    const _id = req.query.id;
+    console.log(_id);
     const { error } = validation.validate(_id);
     if (error) {
       import_node_server_utils57.logger.log({ level: "error", message: error.message });
@@ -12806,7 +12812,7 @@ function useSiteController() {
     const validation = import_joi36.default.object({
       _id: import_joi36.default.string().hex().required(),
       field: import_joi36.default.string().valid(...allowedFieldsSite).required(),
-      value: import_joi36.default.number().integer().min(0).required()
+      value: import_joi36.default.alternatives().try(import_joi36.default.number().integer().min(0), import_joi36.default.string().hex().length(24)).required()
     });
     const _id = req.params.id ?? "";
     const field = req.body.field ?? "";
@@ -27056,11 +27062,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";
@@ -27122,7 +27128,8 @@ var MAccessCard = class {
     doorName,
     liftName,
     replacementStatus,
-    vmsRemarks
+    vmsRemarks,
+    isWinsland = false
   } = {}) {
     this._id = _id;
     this.userId = userId;
@@ -27149,6 +27156,7 @@ var MAccessCard = class {
     this.liftName = liftName;
     this.replacementStatus = replacementStatus;
     this.vmsRemarks = vmsRemarks;
+    this.isWinsland = isWinsland;
   }
 };
 
@@ -27198,6 +27206,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
   }) {
@@ -27288,7 +27305,8 @@ function UseAccessManagementRepo() {
                 liftName: params.liftName,
                 assignedUnit: new import_mongodb83.ObjectId(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);
@@ -27340,7 +27358,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);
@@ -27372,10 +27391,362 @@ function UseAccessManagementRepo() {
       throw new Error(error.message);
     }
   }
+  async function accessManagementSettingsRepo(params) {
+    try {
+      params.site = new import_mongodb83.ObjectId(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 import_mongodb83.ObjectId(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 import_mongodb83.ObjectId(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 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:
+          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()] } }
+            ]
+          };
+        case 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 import_mongodb83.ObjectId(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 = (0, import_node_server_utils149.paginate)(items, page, limit, totalCount);
+      return paginatedResult;
+    } catch (error) {
+      throw new Error(error.message);
+    }
+  }
   return {
     createIndexes,
+    createIndexForEntrypass,
     addPhysicalCardRepo,
-    addNonPhysicalCardRepo
+    addNonPhysicalCardRepo,
+    accessManagementSettingsRepo,
+    allAccessCardsCountsRepo,
+    availableAccessCardsRepo,
+    userTypeAccessCardsRepo
   };
 }
 
@@ -27481,7 +27852,14 @@ var formatAccessGroup = (data, search) => {
 // src/services/access-management.service.ts
 var import_xml2js = require("xml2js");
 function useAccessManagementSvc() {
-  const { addPhysicalCardRepo, addNonPhysicalCardRepo } = UseAccessManagementRepo();
+  const {
+    addPhysicalCardRepo,
+    addNonPhysicalCardRepo,
+    accessManagementSettingsRepo,
+    allAccessCardsCountsRepo,
+    availableAccessCardsRepo,
+    userTypeAccessCardsRepo
+  } = UseAccessManagementRepo();
   const addPhysicalCardSvc = async (payload) => {
     try {
       const response = await addPhysicalCardRepo({ payload });
@@ -27528,7 +27906,39 @@ 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);
     }
   };
   return {
@@ -27536,7 +27946,11 @@ function useAccessManagementSvc() {
     addNonPhysicalCardSvc,
     doorAccessLevelsSvc,
     liftAccessLevelsSvc,
-    accessGroupsSvc
+    accessGroupsSvc,
+    accessManagementSettingsSvc,
+    allAccessCardsCountsSvc,
+    availableAccessCardsSvc,
+    userTypeAccessCardsSvc
   };
 }
 
@@ -27547,7 +27961,11 @@ function useAccessManagementController() {
     addNonPhysicalCardSvc,
     doorAccessLevelsSvc,
     liftAccessLevelsSvc,
-    accessGroupsSvc
+    accessGroupsSvc,
+    accessManagementSettingsSvc,
+    allAccessCardsCountsSvc,
+    availableAccessCardsSvc,
+    userTypeAccessCardsSvc
   } = useAccessManagementSvc();
   const addPhysicalCard = async (req, res) => {
     try {
@@ -27607,7 +28025,8 @@ function useAccessManagementController() {
         createdAt,
         updatedAt,
         startDate,
-        endDate
+        endDate,
+        isWinsland
       } = req.body;
       const schema2 = import_joi85.default.object({
         site: import_joi85.default.string().hex().required(),
@@ -27623,7 +28042,8 @@ function useAccessManagementController() {
         startDate: import_joi85.default.date().required(),
         endDate: import_joi85.default.date().required(),
         createdAt: import_joi85.default.date().required(),
-        updatedAt: import_joi85.default.date().required()
+        updatedAt: import_joi85.default.date().required(),
+        isWinsland: import_joi85.default.boolean().optional().allow(null)
       });
       const { error } = schema2.validate({
         site,
@@ -27639,7 +28059,8 @@ function useAccessManagementController() {
         startDate,
         endDate,
         createdAt,
-        updatedAt
+        updatedAt,
+        isWinsland
       });
       if (error) {
         throw new Error(`${error.message}`);
@@ -27658,7 +28079,8 @@ function useAccessManagementController() {
         startDate,
         endDate,
         createdAt,
-        updatedAt
+        updatedAt,
+        isWinsland
       });
       return res.status(201).json({
         data: result,
@@ -27716,12 +28138,100 @@ 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 = import_joi85.default.object({
+        site: import_joi85.default.string().hex().required(),
+        userType: import_joi85.default.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 = import_joi85.default.object({
+        site: import_joi85.default.string().hex().required(),
+        userType: import_joi85.default.string().optional().allow("", null),
+        type: import_joi85.default.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 = import_joi85.default.object({
+        page: import_joi85.default.number().required(),
+        limit: import_joi85.default.number().optional().default(10),
+        site: import_joi85.default.string().hex().required(),
+        organization: import_joi85.default.string().hex().optional().allow("", null),
+        search: import_joi85.default.string().optional().allow("", null),
+        userType: import_joi85.default.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
+      });
+    }
+  };
   return {
     addPhysicalCard,
     addNonPhysicalCard,
     doorAccessLevels,
     liftAccessLevels,
-    accessGroups
+    accessGroups,
+    accessManagementSettings,
+    allAccessCardsCounts,
+    availableAccessCards,
+    userTypeAccessCards
   };
 }
 
@@ -31917,15 +32427,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 = import_node_server_utils174.useAtlas.getClient()?.startSession();
     session?.startTransaction();
@@ -31943,6 +32456,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 import_node_server_utils174.NotFoundError("File not found.");
+          }
+        }
+      }
       const result = await _add(value, session);
       await session?.commitTransaction();
       return result;
@@ -31957,6 +32483,26 @@ function useIncidentReportService() {
     const session = import_node_server_utils174.useAtlas.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.";