Merge pull request #2082 from OneCommunityGlobal/Abhinav-Kitchen-Inventory-Management-Create-Backend-API-endpoints-to-get-events-to-the-calendar

Abhinav kitchen inventory management create backend api endpoints to get events to the calendar

Author: one-community

src/app.js

@@ -15,7 +15,7 @@ app.use(Sentry.Handlers.requestHandler());
 require('./startup/compression')(app);
 require('./startup/cors')(app);
 require('./startup/bodyParser')(app);
-require('./startup/session')(app);  // Add session before middleware and routes
+require('./startup/session')(app); // Add session before middleware and routes
 
 app.use('/api/test', testRoutes);
 

src/controllers/calendarController.js

@@ -0,0 +1,162 @@
+const calendarController = function (CalendarEvent, ProcessingProject) {
+  const getCalendarEvents = async (req, res) => {
+    try {
+      const { month, year, module: moduleFilter } = req.query;
+
+      if (!month || !year) {
+        return res.status(400).send({ error: 'Month and year query parameters are required.' });
+      }
+
+      const monthNum = parseInt(month, 10);
+      const yearNum = parseInt(year, 10);
+
+      if (Number.isNaN(monthNum) || Number.isNaN(yearNum) || monthNum < 1 || monthNum > 12) {
+        return res.status(400).send({ error: 'Invalid month or year value.' });
+      }
+
+      // Build date range: start of month to end of month
+      const startDate = new Date(yearNum, monthNum - 1, 1);
+      const endDate = new Date(yearNum, monthNum, 0, 23, 59, 59, 999);
+
+      // Build query from validated primitives only — never spread user-controlled data
+      const safeQuery = {
+        scheduled_date: { $gte: startDate, $lte: endDate },
+      };
+
+      const validModules = ['garden', 'orchard', 'animals', 'kitchen'];
+
+      if (moduleFilter && !validModules.includes(moduleFilter)) {
+        return res.status(400).send({
+          error: `Invalid module. Must be one of: ${validModules.join(', ')}`,
+        });
+      }
+
+      let events = [];
+
+      if (moduleFilter === 'kitchen') {
+        // Query kitchen events from ProcessingProject collection
+        const kitchenProjects = await ProcessingProject.find(safeQuery).sort({
+          scheduled_date: 1,
+        });
+        events = kitchenProjects.map((project) => ({
+          _id: project._id,
+          title: project.item_name,
+          module: 'kitchen',
+          event_type: project.process_name,
+          scheduled_date: project.scheduled_date,
+          description: '',
+          assigned_to: '',
+          related_item: project.item_name,
+          status: 'scheduled',
+        }));
+      } else if (moduleFilter) {
+        // Look up the module from the whitelist — never use raw user value in query
+        const safeModule = validModules.find((m) => m === moduleFilter);
+        events = await CalendarEvent.find({ ...safeQuery, module: safeModule }).sort({
+          scheduled_date: 1,
+        });
+      } else {
+        // No filter: query all modules in parallel
+        const [calendarEvents, kitchenProjects] = await Promise.all([
+          CalendarEvent.find(safeQuery).sort({ scheduled_date: 1 }),
+          ProcessingProject.find(safeQuery).sort({ scheduled_date: 1 }),
+        ]);
+
+        const normalizedKitchen = kitchenProjects.map((project) => ({
+          _id: project._id,
+          title: project.item_name,
+          module: 'kitchen',
+          event_type: project.process_name,
+          scheduled_date: project.scheduled_date,
+          description: '',
+          assigned_to: '',
+          related_item: project.item_name,
+          status: 'scheduled',
+        }));
+
+        events = [...calendarEvents, ...normalizedKitchen];
+
+        // Sort merged results by scheduled_date
+        events.sort((a, b) => new Date(a.scheduled_date) - new Date(b.scheduled_date));
+      }
+
+      return res.status(200).send({ events });
+    } catch (err) {
+      // eslint-disable-next-line no-console
+      console.error('Error fetching calendar events:', err);
+      return res.status(500).send({ error: 'Internal Server Error' });
+    }
+  };
+
+  const createEvent = async (req, res) => {
+    try {
+      const {
+        title,
+        module: eventModule,
+        event_type,
+        scheduled_date,
+        description,
+        assigned_to,
+        related_item,
+        status,
+      } = req.body;
+
+      if (!title || !eventModule || !event_type || !scheduled_date) {
+        return res.status(400).send({
+          error: 'Title, module, event_type, and scheduled_date are required.',
+        });
+      }
+
+      const validModules = ['garden', 'orchard', 'animals', 'kitchen'];
+      if (!validModules.includes(eventModule)) {
+        return res.status(400).send({
+          error: `Invalid module. Must be one of: ${validModules.join(', ')}`,
+        });
+      }
+
+      const event = new CalendarEvent({
+        title,
+        module: eventModule,
+        event_type,
+        scheduled_date,
+        description,
+        assigned_to,
+        related_item,
+        status,
+      });
+
+      await event.save();
+      return res.status(201).send(event);
+    } catch (err) {
+      // eslint-disable-next-line no-console
+      console.error('Error creating calendar event:', err);
+      return res.status(500).send({ error: 'Internal Server Error' });
+    }
+  };
+
+  const deleteEvent = async (req, res) => {
+    try {
+      const { id } = req.params;
+
+      const event = await CalendarEvent.findById(id);
+      if (!event) {
+        return res.status(404).send({ error: 'Event not found.' });
+      }
+
+      await CalendarEvent.findByIdAndDelete(id);
+      return res.status(200).send({ message: 'Event successfully deleted.' });
+    } catch (err) {
+      // eslint-disable-next-line no-console
+      console.error('Error deleting calendar event:', err);
+      return res.status(500).send({ error: 'Internal Server Error' });
+    }
+  };
+
+  return {
+    getCalendarEvents,
+    createEvent,
+    deleteEvent,
+  };
+};
+
+module.exports = calendarController;

src/controllers/processingProjectController.js

@@ -0,0 +1,64 @@
+const mongoose = require('mongoose');
+
+const processingProjectController = function (ProcessingProject) {
+  const postProject = async (req, res) => {
+    try {
+      const {
+        item_name,
+        process_name,
+        quantity,
+        unit,
+        batches,
+        supplies_quantity,
+        supplies_type,
+        scheduled_date,
+        priority,
+      } = req.body;
+
+      if (!item_name || !process_name || !quantity) {
+        return res
+          .status(400)
+          .send({ error: 'Item name, process name, and quantity are required.' });
+      }
+
+      const project = new ProcessingProject({
+        item_name,
+        process_name,
+        quantity,
+        unit,
+        batches,
+        supplies_quantity,
+        supplies_type,
+        scheduled_date,
+        priority,
+      });
+
+      await project.save();
+      res.status(201).send(project);
+    } catch (err) {
+      console.error(err);
+      res.status(500).send({ error: 'Internal Server Error' });
+    }
+  };
+
+  const getProjects = async (req, res) => {
+    try {
+      // Get all projects, sorted by scheduled_date ascending (upcoming first)
+      // If user wants "current and upcoming", we technically might want to filter scheduled_date >= today
+      // But based on the request "get all the current and upcoming projects", returning all sorted is a good start.
+      const projects = await ProcessingProject.find().sort({ scheduled_date: 1 });
+
+      res.status(200).send(projects);
+    } catch (err) {
+      console.error(err);
+      res.status(500).send({ error: 'Internal Server Error' });
+    }
+  };
+
+  return {
+    postProject,
+    getProjects,
+  };
+};
+
+module.exports = processingProjectController;

src/controllers/progressController.js

@@ -210,7 +210,10 @@ const progressController = function () {
       }
 
       // Check if progress record already exists
-      const existingProgress = await Progress.findOne({ studentId: sanitizedStudentId, atomId: sanitizedAtomId });
+      const existingProgress = await Progress.findOne({
+        studentId: sanitizedStudentId,
+        atomId: sanitizedAtomId,
+      });
       if (existingProgress) {
         return res
           .status(400)
@@ -532,7 +535,9 @@ const progressController = function () {
         .select('name description difficulty moleculeType subjectId');
 
       // Find unearned atoms (atoms not in progress records)
-      const progressAtomIds = new Set(progressRecords.map((p) => p.atomId?._id.toString()).filter(Boolean));
+      const progressAtomIds = new Set(
+        progressRecords.map((p) => p.atomId?._id.toString()).filter(Boolean),
+      );
       const unearnedAtoms = allAtoms
         .filter((atom) => !progressAtomIds.has(atom._id.toString()))
         .map((atom) => ({