Backend Release to Main [2.93]

package.json

@@ -29,7 +29,8 @@
     "serve": "babel-node src/server.js",
     "prepare-macos-linux": "husky install && chmod ug+x .husky/* && chmod ug+x .git/hooks/*",
     "prepare": "husky install",
-    "install": "npm install --ignore-scripts sharp"
+    "install": "npm install --ignore-scripts sharp",
+    "postinstall": "npx puppeteer browsers install chrome"
   },
   "author": "AK",
   "license": "ISC",

src/app.js

@@ -1,9 +1,10 @@
 const express = require('express');
 const Sentry = require('@sentry/node');
+const testRoutes = require('./routes/testRoutes');
 
 const app = express();
 const logger = require('./startup/logger');
 const globalErrorHandler = require('./utilities/errorHandling/globalErrorHandler');
 // const experienceRoutes = require('./routes/applicantAnalyticsRoutes');
 
 logger.init();
@@ -15,6 +16,8 @@
 require('./startup/cors')(app);
 require('./startup/bodyParser')(app);
 
+app.use('/api/test', testRoutes);
+
 const helpFeedbackRouter = require('./routes/helpFeedbackRouter');
 const helpRequestRouter = require('./routes/helpRequestRouter');
 

src/controllers/kitchenandinventory/KIInventoryController.js

@@ -0,0 +1,167 @@
+const KIInventoryItem = require('../../models/kitchenandinventory/KIInventoryItems');
+
+const KIInventoryController = () => {
+  const addItem = async (req, res) => {
+    const {
+      name,
+      storedQuantity,
+      unit,
+      type,
+      monthlyUsage,
+      category,
+      expiryDate,
+      location,
+      onsite,
+      reorderAt,
+      lastHarvestDate,
+      nextHarvestDate,
+      nextHarvestQuantity,
+    } = req.body;
+    const newItem = new KIInventoryItem({
+      name,
+      storedQuantity,
+      presentQuantity: storedQuantity,
+      unit,
+      type,
+      monthlyUsage,
+      category,
+      expiryDate,
+      location,
+      onsite,
+      reorderAt,
+      lastHarvestDate,
+      nextHarvestDate,
+      nextHarvestQuantity,
+    });
+    try {
+      const savedItem = await newItem.save();
+      res.status(201).json({
+        message: 'Inventory item added successfully',
+        data: savedItem,
+      });
+    } catch (error) {
+      res.status(400).json({ message: error.message });
+    }
+  };
+  const getItems = async (req, res) => {
+    try {
+      const items = await KIInventoryItem.find(null, { __v: 0 }).lean().sort({ createdAt: -1 });
+      res.status(200).json({ message: 'All Items fetched successfully.', data: items });
+    } catch (err) {
+      res.status(400).json({ message: 'Something went wrong while fetching items.' });
+    }
+  };
+  const getItemsByCategory = async (req, res) => {
+    const { category } = req.params;
+    try {
+      const items = await KIInventoryItem.find({ category }, { __v: 0 })
+        .lean()
+        .sort({ createdAt: -1 });
+      res.status(200).json({ message: 'Items fetched successfully.', data: items });
+    } catch (err) {
+      res.status(400).json({ message: 'Something went wrong while fetching items.' });
+    }
+  };
+  const getPreservedStock = async (req, res) => {
+    const oneyearFromNow = new Date();
+    oneyearFromNow.setFullYear(oneyearFromNow.getFullYear() + 1);
+    try {
+      const items = await KIInventoryItem.find(
+        { category: 'INGREDIENT', expiryDate: { $gte: oneyearFromNow } },
+        { __v: 0 },
+      )
+        .lean()
+        .sort({ presentQuantity: -1 });
+      res.status(200).json({ message: 'Preserved stock items fetched successfully.', data: items });
+    } catch (err) {
+      res
+        .status(400)
+        .json({ message: 'Something went wrong while fetching preserved stock items.' });
+    }
+  };
+  const updateOnUsage = async (req, res) => {
+    const { itemId, usedQuantity } = req.body;
+    if (usedQuantity <= 0) {
+      return res.status(400).json({ message: 'Used quantity must be greater than zero.' });
+    }
+    try {
+      const item = await KIInventoryItem.findById(itemId);
+      if (!item) {
+        return res.status(404).json({ message: 'Item not found.' });
+      }
+      if (item.expiryDate < new Date()) {
+        return res.status(400).json({ message: `This item was expired on ${item.expiryDate}` });
+      }
+      let present = item.presentQuantity;
+      present -= usedQuantity;
+      if (present < 0) {
+        present = 0;
+      }
+      item.presentQuantity = present;
+      item.updatedAt = new Date();
+      await item.save();
+      res.status(200).json({ message: 'Item usage updated successfully.', data: item });
+    } catch (err) {
+      res.status(400).json({ message: err.message });
+    }
+  };
+  const updateStoredQuantity = async (req, res) => {
+    const { itemId, addedQuantity, newExpiry } = req.body;
+    if (addedQuantity <= 0) {
+      return res.status(400).json({ message: 'Added quantity must be greater than zero.' });
+    }
+    if (newExpiry && new Date(newExpiry) < new Date()) {
+      return res.status(400).json({ message: 'New expiry date must be a future date.' });
+    }
+    try {
+      const item = await KIInventoryItem.findById(itemId);
+      if (!item) {
+        return res.status(404).json({ message: 'Item not found.' });
+      }
+      if (item.presentQuantity === 0 || item.expiryDate < new Date()) {
+        item.storedQuantity = addedQuantity;
+        item.presentQuantity = 0;
+      } else {
+        item.storedQuantity += addedQuantity;
+      }
+      item.presentQuantity += addedQuantity;
+      if (newExpiry) {
+        item.expiryDate = newExpiry;
+      }
+      item.updatedAt = new Date();
+      await item.save();
+      res.status(200).json({ message: 'Stored quantity updated successfully.', data: item });
+    } catch (err) {
+      res.status(400).json({ message: err.message });
+    }
+  };
+  const updateNextHarvest = async (req, res) => {
+    const { itemId, lastHarvestSuccess, nextHarvestDate, nextHarvestQuantity } = req.body;
+    try {
+      const item = await KIInventoryItem.findById(itemId);
+      if (!item) {
+        return res.status(404).json({ message: 'Item not found.' });
+      }
+      if (lastHarvestSuccess) {
+        item.lastHarvestDate = item.nextHarvestDate;
+      }
+      item.nextHarvestDate = nextHarvestDate;
+      item.nextHarvestQuantity = nextHarvestQuantity;
+      item.updatedAt = new Date();
+      await item.save();
+      res.status(200).json({ message: 'Next harvest details updated successfully.', data: item });
+    } catch (err) {
+      res.status(400).json({ message: err.message });
+    }
+  };
+  return {
+    addItem,
+    getItems,
+    getItemsByCategory,
+    getPreservedStock,
+    updateOnUsage,
+    updateStoredQuantity,
+    updateNextHarvest,
+  };
+};
+module.exports = KIInventoryController;

src/controllers/prAnalytics/prGradingConfigController.js

@@ -0,0 +1,63 @@
+const prGradingConfigController = function (PRGradingConfig) {
+  const getAllConfigs = async (req, res) => {
+    try {
+      const configs = await PRGradingConfig.find().sort({ createdAt: -1 });
+      res.status(200).json(configs);
+    } catch (err) {
+      res.status(500).json({ error: 'Failed to fetch configurations', details: err.message });
+    }
+  };
+
+  const createConfig = async (req, res) => {
+    try {
+      const { teamName, reviewerCount, testDataType, reviewerNames, notes } = req.body;
+
+      if (!teamName || !reviewerCount || !testDataType) {
+        return res
+          .status(400)
+          .json({ error: 'teamName, reviewerCount, and testDataType are required.' });
+      }
+
+      if (typeof reviewerCount !== 'number' || reviewerCount < 1) {
+        return res.status(400).json({ error: 'reviewerCount must be a positive number.' });
+      }
+
+      const existing = await PRGradingConfig.findOne({ teamName: teamName.trim() });
+      if (existing) {
+        return res
+          .status(409)
+          .json({ error: `A configuration with team name "${teamName}" already exists.` });
+      }
+
+      const newConfig = new PRGradingConfig({
+        teamName: teamName.trim(),
+        reviewerCount,
+        testDataType,
+        reviewerNames: reviewerNames || [],
+        notes: notes || '',
+      });
+
+      const saved = await newConfig.save();
+      res.status(201).json(saved);
+    } catch (err) {
+      res.status(500).json({ error: 'Failed to create configuration', details: err.message });
+    }
+  };
+
+  const deleteConfig = async (req, res) => {
+    try {
+      const { id } = req.params;
+      const deleted = await PRGradingConfig.findByIdAndDelete(id);
+      if (!deleted) {
+        return res.status(404).json({ error: 'Configuration not found.' });
+      }
+      res.status(200).json({ message: 'Configuration deleted successfully.' });
+    } catch (err) {
+      res.status(500).json({ error: 'Failed to delete configuration', details: err.message });
+    }
+  };
+
+  return { getAllConfigs, createConfig, deleteConfig };
+};
+
+module.exports = prGradingConfigController;

src/controllers/reportsController.js

@@ -623,6 +623,7 @@ const reportsController = function () {
           createdDate: 1,
           getWeeklyReport: 1,
           permissionGrantedToGetWeeklySummaryReport: 1,
+          isActive: 1,
         },
       )
         .then((results) => {

src/controllers/userProfileController.js

@@ -14,6 +14,7 @@ const moment_ = require('moment');
 const jwt = require('jsonwebtoken');
 const userHelper = require('../helpers/userHelper')();
 const TimeEntry = require('../models/timeentry');
+const Team = require('../models/team');
 const logger = require('../startup/logger');
 const Badge = require('../models/badge');
 // eslint-disable-next-line no-unused-vars
@@ -477,7 +478,39 @@ const createControllerMethods = function (UserProfile, Project, cache) {
     }
 
     if (req.body.teams !== undefined) {
-      record.teams = Array.from(new Set(req.body.teams));
+      const updatedTeams = Array.from(new Set(req.body.teams));
+
+      // Find teams that were removed
+      const removedTeams = record.teams.filter(
+        (teamId) => !updatedTeams.includes(teamId.toString()),
+      );
+
+      // Find teams that were added
+      const addedTeams = updatedTeams.filter(
+        (teamId) => !record.teams.map((t) => t.toString()).includes(teamId),
+      );
+
+      // Remove user from Team's members array for each removed team
+      if (removedTeams.length > 0) {
+        await Team.updateMany(
+          { _id: { $in: removedTeams } },
+          { $pull: { members: { userId: mongoose.Types.ObjectId(record._id) } } },
+        );
+      }
+
+      // Add user to Team's members array for each added team
+      if (addedTeams.length > 0) {
+        await Team.updateMany(
+          { _id: { $in: addedTeams } },
+          {
+            $push: {
+              members: { userId: mongoose.Types.ObjectId(record._id), addDateTime: new Date() },
+            },
+          },
+        );
+      }
+
+      record.teams = updatedTeams;
     }
 
     await updateProjects(req, record);