Backend Release to Main [3.11]

package.json

@@ -104,7 +104,7 @@
     "geoip-lite": "^1.4.10",
     "googleapis": "^100.0.0",
     "isomorphic-fetch": "^3.0.0",
-    "joi": "^18.0.1",
+    "joi": "^18.2.1",
     "json2csv": "^6.0.0-alpha.2",
     "jsonwebtoken": "^9.0.0",
     "lodash": "^4.17.21",

src/controllers/activityController.js

@@ -3,6 +3,7 @@ const Activity = require('../models/activity');
 const LessonPlan = require('../models/lessonPlan');
 const Subject = require('../models/subject');
 const Atom = require('../models/atom');
+
 const activityController = function () {
   // Get all activities
   const getActivities = async (req, res) => {

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

@@ -15,6 +15,7 @@ describe('bmEquipmentController', () => {
       findOneAndUpdate: jest.fn(),
       create: jest.fn(),
       findByIdAndUpdate: jest.fn(),
+      updateOne: jest.fn(),
     };
 
     // Initialize controller with mock model
@@ -130,4 +131,148 @@ describe('bmEquipmentController', () => {
       expect(mockRes.status).toHaveBeenCalledWith(201);
     });
   });
+
+  describe('updateEquipmentById', () => {
+    const validObjectId = '507f1f77bcf86cd799439011';
+
+    it('should return 400 for invalid equipment ID', async () => {
+      mockReq.params.equipmentId = 'invalid-id';
+      mockReq.body = { purchaseStatus: 'Purchased' };
+
+      await controller.updateEquipmentById(mockReq, mockRes);
+
+      expect(mockRes.status).toHaveBeenCalledWith(400);
+      expect(mockRes.send).toHaveBeenCalledWith({ message: 'Invalid equipment ID.' });
+      expect(mockBuildingEquipment.updateOne).not.toHaveBeenCalled();
+    });
+
+    it('should return 400 for invalid project ID when provided', async () => {
+      mockReq.params.equipmentId = validObjectId;
+      mockReq.body = { projectId: 'not-valid', purchaseStatus: 'Purchased' };
+
+      await controller.updateEquipmentById(mockReq, mockRes);
+
+      expect(mockRes.status).toHaveBeenCalledWith(400);
+      expect(mockRes.send).toHaveBeenCalledWith({ message: 'Invalid project ID.' });
+      expect(mockBuildingEquipment.updateOne).not.toHaveBeenCalled();
+    });
+
+    it('should return 400 for invalid purchaseStatus enum', async () => {
+      mockReq.params.equipmentId = validObjectId;
+      mockReq.body = { purchaseStatus: 'InvalidStatus' };
+
+      await controller.updateEquipmentById(mockReq, mockRes);
+
+      expect(mockRes.status).toHaveBeenCalledWith(400);
+      expect(mockRes.send).toHaveBeenCalledWith(
+        expect.objectContaining({
+          message: expect.stringContaining('Invalid purchaseStatus'),
+        }),
+      );
+      expect(mockBuildingEquipment.updateOne).not.toHaveBeenCalled();
+    });
+
+    it('should return 400 for invalid currentUsage enum', async () => {
+      mockReq.params.equipmentId = validObjectId;
+      mockReq.body = { currentUsage: 'Broken' };
+
+      await controller.updateEquipmentById(mockReq, mockRes);
+
+      expect(mockRes.status).toHaveBeenCalledWith(400);
+      expect(mockRes.send).toHaveBeenCalledWith(
+        expect.objectContaining({
+          message: expect.stringContaining('Invalid currentUsage'),
+        }),
+      );
+      expect(mockBuildingEquipment.updateOne).not.toHaveBeenCalled();
+    });
+
+    it('should return 400 for invalid condition enum', async () => {
+      mockReq.params.equipmentId = validObjectId;
+      mockReq.body = { condition: 'Unknown' };
+
+      await controller.updateEquipmentById(mockReq, mockRes);
+
+      expect(mockRes.status).toHaveBeenCalledWith(400);
+      expect(mockRes.send).toHaveBeenCalledWith(
+        expect.objectContaining({
+          message: expect.stringContaining('Invalid condition'),
+        }),
+      );
+      expect(mockBuildingEquipment.updateOne).not.toHaveBeenCalled();
+    });
+
+    it('should return 400 when no valid fields provided to update', async () => {
+      mockReq.params.equipmentId = validObjectId;
+      mockReq.body = { unknownField: 'value' };
+
+      await controller.updateEquipmentById(mockReq, mockRes);
+
+      expect(mockRes.status).toHaveBeenCalledWith(400);
+      expect(mockRes.send).toHaveBeenCalledWith({
+        message: 'No valid fields provided to update.',
+      });
+      expect(mockBuildingEquipment.updateOne).not.toHaveBeenCalled();
+    });
+
+    it('should return 200 with updated equipment on success', async () => {
+      const updatedEquipment = {
+        _id: validObjectId,
+        purchaseStatus: 'Purchased',
+        condition: 'Good',
+      };
+      mockReq.params.equipmentId = validObjectId;
+      mockReq.body = { purchaseStatus: 'Purchased', condition: 'Good' };
+
+      mockBuildingEquipment.updateOne.mockResolvedValue({});
+      const mockPopulate = jest.fn().mockReturnThis();
+      const mockExec = jest.fn().mockResolvedValue(updatedEquipment);
+      mockBuildingEquipment.findById.mockReturnValue({
+        populate: mockPopulate,
+        exec: mockExec,
+      });
+
+      await controller.updateEquipmentById(mockReq, mockRes);
+
+      expect(mockBuildingEquipment.updateOne).toHaveBeenCalledWith(
+        { _id: validObjectId },
+        { $set: expect.objectContaining({ purchaseStatus: 'Purchased', condition: 'Good' }) },
+      );
+      expect(mockBuildingEquipment.findById).toHaveBeenCalledWith(validObjectId);
+      expect(mockRes.status).toHaveBeenCalledWith(200);
+      expect(mockRes.send).toHaveBeenCalledWith(updatedEquipment);
+    });
+
+    it('should return 404 when equipment not found after update', async () => {
+      mockReq.params.equipmentId = validObjectId;
+      mockReq.body = { condition: 'Good' };
+
+      mockBuildingEquipment.updateOne.mockResolvedValue({});
+      const mockPopulate = jest.fn().mockReturnThis();
+      const mockExec = jest.fn().mockResolvedValue(null);
+      mockBuildingEquipment.findById.mockReturnValue({
+        populate: mockPopulate,
+        exec: mockExec,
+      });
+
+      await controller.updateEquipmentById(mockReq, mockRes);
+
+      expect(mockRes.status).toHaveBeenCalledWith(404);
+      expect(mockRes.send).toHaveBeenCalledWith({ message: 'Equipment not found.' });
+    });
+
+    it('should return 500 on updateOne error', async () => {
+      mockReq.params.equipmentId = validObjectId;
+      mockReq.body = { condition: 'Good' };
+
+      mockBuildingEquipment.updateOne.mockRejectedValue(new Error('DB error'));
+
+      await controller.updateEquipmentById(mockReq, mockRes);
+
+      expect(mockRes.status).toHaveBeenCalledWith(500);
+      expect(mockRes.send).toHaveBeenCalledWith(
+        expect.objectContaining({ message: expect.any(String) }),
+      );
+    });
+  });
 });

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

@@ -0,0 +1,148 @@
+jest.mock('../../../models/bmdashboard/expenditure', () => ({
+  distinct: jest.fn(),
+  aggregate: jest.fn(),
+}));
+
+jest.mock('../../../startup/logger', () => ({
+  logException: jest.fn(),
+  logInfo: jest.fn(),
+}));
+
+const Expenditure = require('../../../models/bmdashboard/expenditure');
+const logger = require('../../../startup/logger');
+const { getProjectExpensesPie, getProjectIdsWithExpenditure } = require('../expenditureController');
+
+const VALID_ID = '507f1f77bcf86cd799439011';
+const INVALID_ID = 'not-a-valid-id';
+
+const makeRes = () => {
+  const res = {};
+  res.status = jest.fn().mockReturnThis();
+  res.json = jest.fn().mockReturnThis();
+  return res;
+};
+
+describe('expenditureController', () => {
+  beforeEach(() => {
+    jest.clearAllMocks();
+  });
+
+  // ---------------------------------------------------------------------------
+  describe('getProjectIdsWithExpenditure', () => {
+    it('returns 200 with the array of project IDs on success', async () => {
+      const ids = [VALID_ID, '507f1f77bcf86cd799439012'];
+      Expenditure.distinct.mockResolvedValue(ids);
+
+      const res = makeRes();
+      await getProjectIdsWithExpenditure({}, res);
+
+      expect(Expenditure.distinct).toHaveBeenCalledWith('projectId');
+      expect(res.status).toHaveBeenCalledWith(200);
+      expect(res.json).toHaveBeenCalledWith(ids);
+    });
+
+    it('returns 200 with an empty array when no expenditure records exist', async () => {
+      Expenditure.distinct.mockResolvedValue([]);
+
+      const res = makeRes();
+      await getProjectIdsWithExpenditure({}, res);
+
+      expect(res.status).toHaveBeenCalledWith(200);
+      expect(res.json).toHaveBeenCalledWith([]);
+    });
+
+    it('returns 500 and calls logger on DB error', async () => {
+      const error = new Error('DB failure');
+      Expenditure.distinct.mockRejectedValue(error);
+
+      const res = makeRes();
+      await getProjectIdsWithExpenditure({}, res);
+
+      expect(res.status).toHaveBeenCalledWith(500);
+      expect(res.json).toHaveBeenCalledWith({ message: 'Failed to retrieve project IDs' });
+      expect(logger.logException).toHaveBeenCalledWith(
+        error,
+        'expenditureController.getProjectIdsWithExpenditure',
+      );
+    });
+  });
+
+  // ---------------------------------------------------------------------------
+  describe('getProjectExpensesPie', () => {
+    it('returns 400 for an invalid projectId without calling aggregate', async () => {
+      const req = { params: { projectId: INVALID_ID } };
+      const res = makeRes();
+
+      await getProjectExpensesPie(req, res);
+
+      expect(res.status).toHaveBeenCalledWith(400);
+      expect(res.json).toHaveBeenCalledWith({ message: 'Invalid project ID' });
+      expect(Expenditure.aggregate).not.toHaveBeenCalled();
+    });
+
+    it('returns 400 for a short non-hex string without calling aggregate', async () => {
+      const req = { params: { projectId: '12345' } };
+      const res = makeRes();
+
+      await getProjectExpensesPie(req, res);
+
+      expect(res.status).toHaveBeenCalledWith(400);
+      expect(Expenditure.aggregate).not.toHaveBeenCalled();
+    });
+
+    it('returns 200 with { actual, planned } shape on success', async () => {
+      Expenditure.aggregate.mockResolvedValue([
+        { _id: { type: 'actual', category: 'Labor' }, amount: 1000 },
+        { _id: { type: 'actual', category: 'Materials' }, amount: 500 },
+        { _id: { type: 'planned', category: 'Equipment' }, amount: 2000 },
+      ]);
+
+      const req = { params: { projectId: VALID_ID } };
+      const res = makeRes();
+
+      await getProjectExpensesPie(req, res);
+
+      expect(Expenditure.aggregate).toHaveBeenCalledTimes(1);
+      expect(res.json).toHaveBeenCalledWith({
+        actual: [
+          { category: 'Labor', amount: 1000 },
+          { category: 'Materials', amount: 500 },
+        ],
+        planned: [{ category: 'Equipment', amount: 2000 }],
+      });
+      // status should NOT be explicitly set to 200 (res.json implies 200)
+      expect(res.status).not.toHaveBeenCalled();
+    });
+
+    it('returns { actual: [], planned: [] } when no matching records exist', async () => {
+      Expenditure.aggregate.mockResolvedValue([]);
+
+      const req = { params: { projectId: VALID_ID } };
+      const res = makeRes();
+
+      await getProjectExpensesPie(req, res);
+
+      expect(res.json).toHaveBeenCalledWith({ actual: [], planned: [] });
+    });
+
+    it('returns 500 and calls logger with projectId on DB error', async () => {
+      const error = new Error('Aggregate failed');
+      Expenditure.aggregate.mockRejectedValue(error);
+
+      const req = { params: { projectId: VALID_ID } };
+      const res = makeRes();
+
+      await getProjectExpensesPie(req, res);
+
+      expect(res.status).toHaveBeenCalledWith(500);
+      expect(res.json).toHaveBeenCalledWith({
+        message: 'Server error retrieving expenses pie data.',
+      });
+      expect(logger.logException).toHaveBeenCalledWith(
+        error,
+        'expenditureController.getProjectExpensesPie',
+        { projectId: VALID_ID },
+      );
+    });
+  });
+});

src/controllers/bmdashboard/bmIssueController.js

@@ -273,18 +273,37 @@ const bmIssueController = function (BuildingIssue, injuryIssue) {
         query.projectId = { $in: filteredProjectIds };
       }
 
-      const issues = await BuildingIssue.find(query)
-        .select('issueTitle issueDate projectId')
-        .populate({
-          path: 'projectId',
-          select: 'projectName name',
-        })
+      let issues = await BuildingIssue.find(query)
+        .select('issueTitle issueDate _id')
+        .populate('projectId')
         .lean();
 
-      const grouped = buildGroupedIssues(issues);
-      const response = buildLongestOpenResponse(grouped);
+      issues = issues.map((issue) => {
+        const durationInMonths = getDurationOpenMonths(issue.issueDate);
+        return {
+          issueName: issue.issueTitle && issue.issueTitle.length > 0 ? issue.issueTitle[0] : null,
+          durationInMonths,
+          issueId: issue._id.toString(),
+          projectId: issue.projectId?._id?.toString() || issue.projectId?.toString(),
+          projectName: issue.projectId?.name || null,
+        };
+      });
+
+      const sortedIssues = issues
+        .sort((a, b) => b.durationInMonths - a.durationInMonths)
+        .map(({ issueName, durationInMonths, issueId, projectId, projectName }) => ({
+          issueName,
+          durationOpen: durationInMonths,
+          issueId,
+          projectId,
+          projectName,
+        }));
+
+      console.log(
+        `[getLongestOpenIssues] Total issues found: ${issues.length}, Returning: ${sortedIssues.length} issues`,
+      );
 
-      res.json(response);
+      res.json(sortedIssues);
     } catch (error) {
       res.status(500).json({ message: 'Error fetching longest open issues' });
     }