Backend Release to Main [2.98]

package.json

@@ -140,4 +140,4 @@
       "/src/**/*"
     ]
   }
-}
+}

src/controllers/badgeController.js

@@ -3,7 +3,7 @@ const UserProfile = require('../models/userProfile');
 const helper = require('../utilities/permissions');
 const escapeRegex = require('../utilities/escapeRegex');
 const cacheClosure = require('../utilities/nodeCache');
-// const userHelper = require('../helpers/userHelper')();
+const userHelper = require('../helpers/userHelper')();
 
 const badgeController = function (Badge) {
   /**
@@ -13,10 +13,10 @@ const badgeController = function (Badge) {
    */
   const cache = cacheClosure();
 
-  // const awardBadgesTest = async function (req, res) {
-  //   await userHelper.awardNewBadges();
-  //   res.status(200).send('Badges awarded');
-  // };
+  const awardNewBadges = async function (req, res) {
+    await userHelper.awardNewBadges();
+    res.status(200).send('Badges awarded');
+  };
 
   const getAllBadges = async function (req, res) {
     // console.log(req.body.requestor);  // Retain logging from development branch for debugging
@@ -341,7 +341,7 @@ const badgeController = function (Badge) {
   };
 
   return {
-    // awardBadgesTest,
+    awardNewBadges,
     getAllBadges,
     assignBadges,
     postBadge,

src/controllers/bmdashboard/__tests__/bmInventoryTypeController.test.js

@@ -33,6 +33,11 @@ const mockEquipType = {
   exec: jest.fn(),
 };
 
+const mockInvTypeHistory = {
+  find: jest.fn(),
+  create: jest.fn(),
+  exec: jest.fn(),
+};
 const mockInvType = {
   find: jest.fn(),
   findById: jest.fn(),
@@ -64,6 +69,7 @@ describe('Building Materials Inventory Controller', () => {
       mockReusType,
       mockToolType,
       mockEquipType,
+      mockInvTypeHistory,
     );
 
     req = {
@@ -173,36 +179,4 @@ describe('Building Materials Inventory Controller', () => {
       expect(res.send).toHaveBeenCalledWith(mockTools);
     });
   });
-
-  describe('updateNameAndUnit', () => {
-    it('should update name and unit successfully', async () => {
-      req.params = { invtypeId: 'inv123' };
-      req.body = { name: 'Updated Name', unit: 'Updated Unit' };
-
-      const updatedDoc = { ...req.body, _id: 'inv123' };
-      mockInvType.findByIdAndUpdate.mockResolvedValue(updatedDoc);
-
-      await controller.updateNameAndUnit(req, res);
-
-      expect(mockInvType.findByIdAndUpdate).toHaveBeenCalledWith(
-        'inv123',
-        { name: 'Updated Name', unit: 'Updated Unit' },
-        { new: true, runValidators: true },
-      );
-      expect(res.status).toHaveBeenCalledWith(200);
-      expect(res.json).toHaveBeenCalledWith(updatedDoc);
-    });
-
-    it('should handle non-existent inventory type', async () => {
-      req.params = { invtypeId: 'nonexistent' };
-      req.body = { name: 'Updated Name' };
-
-      mockInvType.findByIdAndUpdate.mockResolvedValue(null);
-
-      await controller.updateNameAndUnit(req, res);
-
-      expect(res.status).toHaveBeenCalledWith(404);
-      expect(res.json).toHaveBeenCalledWith({ error: 'invType Material not found check Id' });
-    });
-  });
 });

src/controllers/bmdashboard/bmInventoryTypeController.js

@@ -1,6 +1,7 @@
 const fs = require('fs');
 const fsPromises = require('fs/promises');
 const path = require('path');
+const mongoose = require('mongoose');
 
 const filename = 'BuildingUnits.json';
 const currentFilePath = __filename;
@@ -9,7 +10,15 @@ const filepath = path.join(rootPath, filename);
 const { readFile } = fs;
 const { writeFile } = fs;
 
-function bmInventoryTypeController(InvType, MatType, ConsType, ReusType, ToolType, EquipType) {
+function bmInventoryTypeController(
+  InvType,
+  MatType,
+  ConsType,
+  ReusType,
+  ToolType,
+  EquipType,
+  invTypeHistory,
+) {
   async function fetchMaterialTypes(req, res) {
     try {
       MatType.find()
@@ -398,22 +407,98 @@ function bmInventoryTypeController(InvType, MatType, ConsType, ReusType, ToolTyp
   };
 
   const updateNameAndUnit = async (req, res) => {
-    const { invtypeId } = req.params;
-    const { name, unit } = req.body;
-
     try {
-      const updatedInvType = await InvType.findByIdAndUpdate(
-        invtypeId,
-        { name, unit },
-        { new: true, runValidators: true },
-      );
-
-      if (!updatedInvType) {
-        return res.status(404).json({ error: 'invType Material not found check Id' });
+      const { invtypeId } = req.params;
+      const {
+        name,
+        unit,
+        type: rawType,
+        requestor: { requestorId },
+      } = req.body;
+      const historyDocs = [];
+      const updateData = {};
+      // Selection of Collection depending on Type
+      const allowedTypes = ['Material', 'Consumable'];
+      const itemTtype = allowedTypes.includes(rawType) ? rawType : 'Inventory';
+
+      // Validate invtypeId
+      if (!mongoose.Types.ObjectId.isValid(invtypeId)) {
+        return res.status(400).json({ message: 'Invalid inventory type ID' });
+      }
+      // Sanitize name
+      const safeName = String(name).trim();
+      if (!safeName) {
+        return res.status(400).json({ message: 'Invalid inventory name' });
+      }
+      // Extract and sanitize
+      const safeUnit = String(unit).trim();
+      if (!safeUnit || safeUnit.length > 50) {
+        return res.status(400).json({ message: 'Invalid unit value' });
+      }
+
+      let CollectionName = InvType;
+      if (itemTtype === 'Material') {
+        CollectionName = MatType;
+      } else if (itemTtype === 'Consumable') {
+        CollectionName = ConsType;
+      }
+
+      // Fetch existing document
+      const invType = await CollectionName.findById(invtypeId);
+      if (!invType) {
+        return res.status(404).send('Inventory type not found check Id');
+      }
+
+      // Perform query using sanitized values
+      const existingInvType = await CollectionName.findOne({
+        name: safeName,
+        _id: { $ne: mongoose.Types.ObjectId(invtypeId) },
+      });
+
+      if (existingInvType) {
+        return res.status(409).json({
+          message: 'Inventory type name already exists',
+        });
+      }
+
+      // Track name change
+      if (safeName && safeName !== invType.name) {
+        historyDocs.push({
+          invtypeId,
+          field: 'name',
+          oldValue: invType.name,
+          newValue: safeName,
+          editedBy: requestorId,
+        });
+        updateData.name = safeName;
+      }
+
+      // Track unit change
+      if (safeUnit && safeUnit !== invType.unit) {
+        historyDocs.push({
+          invtypeId,
+          field: 'unit',
+          oldValue: invType.unit,
+          newValue: safeUnit,
+          editedBy: requestorId,
+        });
+        updateData.unit = safeUnit;
+      }
+
+      //  Save history (if any)
+      if (historyDocs.length > 0) {
+        await invTypeHistory.insertMany(historyDocs);
       }
 
+      // Update main document
+      const updatedInvType = await CollectionName.findByIdAndUpdate(invtypeId, updateData, {
+        new: true,
+        runValidators: true,
+      });
+
       res.status(200).json(updatedInvType);
     } catch (error) {
+      console.error(error);
       res.status(500).send(error);
     }
   };
@@ -638,6 +723,26 @@ function bmInventoryTypeController(InvType, MatType, ConsType, ReusType, ToolTyp
     }
   };
 
+  const fetchInvTypeHistory = async (req, res) => {
+    try {
+      const { invtypeId } = req.params;
+      const safeInvTypeId = new mongoose.Types.ObjectId(invtypeId);
+      if (!mongoose.Types.ObjectId.isValid(invtypeId)) {
+        return res.status(400).json({ message: 'Invalid inventory type id' });
+      }
+
+      const history = await invTypeHistory
+        .find({ invtypeId: safeInvTypeId })
+        .populate('editedBy', '_id firstName lastName email')
+        .sort({ editedAt: -1 })
+        .lean();
+
+      res.status(200).json(history);
+    } catch (error) {
+      console.error('Fetch history error:', error);
+      res.status(500).json({ message: 'Failed to fetch inventory history' });
+    }
+  };
   return {
     fetchMaterialTypes,
     fetchConsumableTypes,
@@ -657,6 +762,7 @@ function bmInventoryTypeController(InvType, MatType, ConsType, ReusType, ToolTyp
     deleteInvUnit,
     updateSingleInvType,
     deleteSingleInvType,
+    fetchInvTypeHistory,
   };
 }