Merge pull request #1866 from OneCommunityGlobal/feature/education-progress-api

one-community · web-flow · commit 91f82faa91df · 2026-04-30T15:52:28.000-07:00
Mani shashank  feat: Add Education Progress API endpoints
diff --git a/src/controllers/progressController.js b/src/controllers/progressController.js
@@ -1,7 +1,114 @@
-// const mongoose = require('mongoose');
+const mongoose = require('mongoose');
 const Progress = require('../models/progress');
 const UserProfile = require('../models/userProfile');
 const Atom = require('../models/atom');
+const EducationStudentProfile = require('../models/educationStudentProfile');
+
+const normalizeToArray = (value) => {
+  if (Array.isArray(value)) {
+    return value;
+  }
+
+  if (value === null || value === undefined) {
+    return [];
+  }
+
+  return [value];
+};
+
+const buildManualStudentProgressResponse = (profile) => {
+  const completedAtoms = [];
+  const inProgressAtoms = [];
+  const notStartedAtoms = [];
+
+  const subjects = Array.isArray(profile.subjects) ? profile.subjects : [];
+
+  subjects.forEach((subject) => {
+    const subjectName = subject?.name || 'General';
+    const molecules = Array.isArray(subject?.molecules) ? subject.molecules : [];
+
+    molecules.forEach((molecule, index) => {
+      const status = molecule?.status || 'not_started';
+      const fallbackId = `${subjectName}-${molecule?.label || molecule?.name || index}`
+        .toLowerCase()
+        .replace(/[^a-z0-9]+/g, '-');
+
+      const atomData = {
+        atomId: molecule?.atomId || fallbackId,
+        name: molecule?.label || molecule?.name || `Molecule ${index + 1}`,
+        description: molecule?.description || '',
+        difficulty: molecule?.difficulty || 'medium',
+        moleculeType: molecule?.moleculeType || subjectName,
+        subject: subjectName,
+        status,
+        grade: molecule?.grade || (status === 'completed' ? 'A' : 'pending'),
+        timestamp:
+          molecule?.completedAt ||
+          molecule?.startedAt ||
+          profile?.updatedAt ||
+          profile?.createdAt ||
+          null,
+        sourceTask: molecule?.sourceTask
+          ? {
+              reference: molecule.sourceTask,
+              taskType: molecule?.taskType || null,
+              lessonPlan: molecule?.lessonPlan || null,
+              assignedAt: molecule?.assignedAt || null,
+              completedAt: molecule?.completedAt || null,
+            }
+          : null,
+      };
+
+      if (status === 'completed') {
+        completedAtoms.push(atomData);
+      } else if (status === 'in_progress') {
+        inProgressAtoms.push(atomData);
+      } else {
+        notStartedAtoms.push(atomData);
+      }
+    });
+  });
+
+  const summaryTotals = profile?.progressSummary || {};
+  const totalAtomsFallback =
+    completedAtoms.length + inProgressAtoms.length + notStartedAtoms.length;
+
+  return {
+    student: {
+      id: profile._id,
+      firstName: profile?.firstName || (profile?.name ? profile.name.split(' ')[0] : 'Student'),
+      lastName:
+        profile?.lastName || (profile?.name ? profile.name.split(' ').slice(1).join(' ') : ''),
+      email: profile?.email || '',
+      profilePic: profile?.avatarUrl || null,
+      location: profile?.location || '',
+      educationProfile: {
+        learningLevel: profile?.gradeLevel || profile?.learningLevel || null,
+        strengths: normalizeToArray(
+          profile?.strengths ||
+            profile?.educationProfile?.student?.strengths ||
+            profile?.student?.strengths,
+        ),
+        challengingAreas: normalizeToArray(
+          profile?.challengingAreas ||
+            profile?.educationProfile?.student?.challengingAreas ||
+            profile?.student?.challengingAreas,
+        ),
+      },
+    },
+    progress: {
+      completed: completedAtoms,
+      inProgress: inProgressAtoms,
+      notStarted: notStartedAtoms,
+    },
+    summary: {
+      totalCompleted: summaryTotals.totalCompleted ?? completedAtoms.length,
+      totalInProgress: summaryTotals.totalInProgress ?? inProgressAtoms.length,
+      totalNotStarted: summaryTotals.totalNotStarted ?? notStartedAtoms.length,
+      totalAtoms: summaryTotals.totalAtoms ?? totalAtomsFallback,
+    },
+  };
+};
 
 const progressController = function () {
   // Get all progress records
@@ -86,29 +193,33 @@ const progressController = function () {
     try {
       const { studentId, atomId, status, grade, feedback } = req.body;
 
+      // Sanitize inputs to prevent NoSQL injection
+      const sanitizedStudentId = String(studentId);
+      const sanitizedAtomId = String(atomId);
+
       // Validate student exists
-      const student = await UserProfile.findById(studentId);
+      const student = await UserProfile.findById(sanitizedStudentId);
       if (!student) {
         return res.status(404).json({ error: 'Student not found' });
       }
 
       // Validate atom exists
-      const atom = await Atom.findById(atomId);
+      const atom = await Atom.findById(sanitizedAtomId);
       if (!atom) {
         return res.status(404).json({ error: 'Atom not found' });
       }
 
       // Check if progress record already exists
-      const existingProgress = await Progress.findOne({ studentId, atomId });
+      const existingProgress = await Progress.findOne({ studentId: sanitizedStudentId, atomId: sanitizedAtomId });
       if (existingProgress) {
         return res
           .status(400)
           .json({ error: 'Progress record already exists for this student and atom' });
       }
 
       const progress = new Progress({
-        studentId,
-        atomId,
+        studentId: sanitizedStudentId,
+        atomId: sanitizedAtomId,
         status: status || 'not_started',
         grade: grade || 'pending',
         feedback,
@@ -324,6 +435,156 @@ const progressController = function () {
     }
   };
 
+  // Get educator view of student progress with molecules (atoms)
+  const getEducatorStudentProgress = async (req, res) => {
+    try {
+      const { studentId } = req.params;
+
+      let manualProfile = null;
+      if (mongoose.Types.ObjectId.isValid(studentId)) {
+        manualProfile = await EducationStudentProfile.findById(studentId).lean();
+      }
+
+      if (manualProfile) {
+        const response = buildManualStudentProgressResponse(manualProfile);
+        return res.status(200).json(response);
+      }
+
+      const EducationTask = require('../models/educationTask');
+
+      // Validate student exists
+      const student = await UserProfile.findById(studentId).select(
+        'firstName lastName email educationProfiles profilePic location',
+      );
+
+      if (!student) {
+        return res.status(404).json({ error: 'Student not found' });
+      }
+
+      // Get all atoms and their progress for this student
+      const progressRecords = await Progress.find({ studentId })
+        .populate({
+          path: 'atomId',
+          select: 'name description difficulty subjectId moleculeType',
+          populate: {
+            path: 'subjectId',
+            select: 'name',
+          },
+        })
+        .sort({ updatedAt: -1 });
+
+      // Get all tasks for this student to find source task info
+      const tasks = await EducationTask.find({ studentId })
+        .populate('lessonPlanId', 'title theme')
+        .populate('atomIds', 'name');
+
+      // Create a map of atomId to task info
+      const atomToTaskMap = {};
+      tasks.forEach((task) => {
+        if (task.atomIds && task.atomIds.length > 0) {
+          task.atomIds.forEach((atom) => {
+            if (!atomToTaskMap[atom._id]) {
+              atomToTaskMap[atom._id] = {
+                taskId: task._id,
+                taskType: task.type,
+                lessonPlan: task.lessonPlanId ? task.lessonPlanId.title : null,
+                assignedAt: task.assignedAt,
+                completedAt: task.completedAt,
+              };
+            }
+          });
+        }
+      });
+
+      // Categorize atoms by status
+      const completedAtoms = [];
+      const inProgressAtoms = [];
+      const notStartedAtoms = [];
+
+      progressRecords.forEach((progress) => {
+        if (!progress.atomId) return;
+
+        const atomData = {
+          atomId: progress.atomId._id,
+          name: progress.atomId.name,
+          description: progress.atomId.description,
+          difficulty: progress.atomId.difficulty,
+          moleculeType: progress.atomId.moleculeType,
+          subject: progress.atomId.subjectId ? progress.atomId.subjectId.name : null,
+          status: progress.status,
+          grade: progress.grade,
+          timestamp: progress.updatedAt,
+          sourceTask: atomToTaskMap[progress.atomId._id] || null,
+        };
+
+        if (progress.status === 'completed') {
+          completedAtoms.push(atomData);
+        } else if (progress.status === 'in_progress') {
+          inProgressAtoms.push(atomData);
+        } else {
+          notStartedAtoms.push(atomData);
+        }
+      });
+
+      // Get all atoms to show unearned ones
+      const allAtoms = await Atom.find({})
+        .populate('subjectId', 'name')
+        .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 unearnedAtoms = allAtoms
+        .filter((atom) => !progressAtomIds.has(atom._id.toString()))
+        .map((atom) => ({
+          atomId: atom._id,
+          name: atom.name,
+          description: atom.description,
+          difficulty: atom.difficulty,
+          moleculeType: atom.moleculeType,
+          subject: atom.subjectId ? atom.subjectId.name : null,
+          status: 'not_started',
+          grade: 'pending',
+          timestamp: null,
+          sourceTask: null,
+        }));
+
+      const locationParts = [];
+      if (student?.location?.city) {
+        locationParts.push(student.location.city);
+      }
+      if (student?.location?.country) {
+        locationParts.push(student.location.country);
+      }
+
+      const response = {
+        student: {
+          id: student._id,
+          firstName: student.firstName,
+          lastName: student.lastName,
+          email: student.email,
+          profilePic: student.profilePic || null,
+          location: locationParts.join(', '),
+          educationProfile: student.educationProfiles?.student || null,
+        },
+        progress: {
+          completed: completedAtoms,
+          inProgress: inProgressAtoms,
+          notStarted: notStartedAtoms.concat(unearnedAtoms),
+        },
+        summary: {
+          totalCompleted: completedAtoms.length,
+          totalInProgress: inProgressAtoms.length,
+          totalNotStarted: notStartedAtoms.length + unearnedAtoms.length,
+          totalAtoms: allAtoms.length,
+        },
+      };
+
+      res.status(200).json(response);
+    } catch (error) {
+      res.status(500).json({ error: error.message });
+    }
+  };
+
   return {
     getProgress,
     getProgressByStudent,
@@ -337,6 +598,7 @@ const progressController = function () {
     gradeProgress,
     getProgressByStatus,
     getStudentProgressSummary,
+    getEducatorStudentProgress,
   };
 };
 
diff --git a/src/models/educationStudentProfile.js b/src/models/educationStudentProfile.js
@@ -0,0 +1,12 @@
+const mongoose = require('mongoose');
+
+const educationStudentProfileSchema = new mongoose.Schema(
+  {},
+  {
+    collection: 'education_student_profiles',
+    strict: false,
+    timestamps: false,
+  },
+);
+
+module.exports = mongoose.model('EducationStudentProfile', educationStudentProfileSchema);
diff --git a/src/routes/progressRouter.js b/src/routes/progressRouter.js
@@ -0,0 +1,45 @@
+const express = require('express');
+
+const router = express.Router();
+const progressController = require('../controllers/progressController')();
+
+// Educator endpoint - get student progress with molecules visualization data
+router.get('/educator/student-progress/:studentId', progressController.getEducatorStudentProgress);
+
+// Get all progress records
+router.get('/', progressController.getProgress);
+
+// Get progress by student
+router.get('/student/:studentId', progressController.getProgressByStudent);
+
+// Get progress by atom
+router.get('/atom/:atomId', progressController.getProgressByAtom);
+
+// Get progress by status
+router.get('/status/:status', progressController.getProgressByStatus);
+
+// Get student progress summary
+router.get('/summary/:studentId', progressController.getStudentProgressSummary);
+
+// Get specific progress record
+router.get('/:id', progressController.getProgressById);
+
+// Get progress by student and atom
+router.get('/student/:studentId/atom/:atomId', progressController.getProgressByStudentAndAtom);
+
+// Create new progress record
+router.post('/', progressController.createProgress);
+
+// Update progress
+router.patch('/:id', progressController.updateProgress);
+
+// Delete progress
+router.delete('/:id', progressController.deleteProgress);
+
+// Update progress status
+router.patch('/:id/status', progressController.updateProgressStatus);
+
+// Grade progress
+router.patch('/:id/grade', progressController.gradeProgress);
+
+module.exports = router;
diff --git a/src/startup/routes.js b/src/startup/routes.js
@@ -54,6 +54,7 @@ const title = require('../models/title');
 const blueSquareEmailAssignment = require('../models/BlueSquareEmailAssignment');
 const hgnformRouter = require('../routes/hgnformRouter');
 const hgnFormResponseRouter = require('../routes/hgnFormResponseRouter');
+const progressRouter = require('../routes/progressRouter');
 
 const questionnaireAnalyticsRouter = require('../routes/questionnaireAnalyticsRouter');
 const applicantAnalyticsRouter = require('../routes/applicantAnalyticsRoutes');
@@ -475,6 +476,7 @@ module.exports = function (app) {
   app.use('/api/questions', hgnformRouter);
   app.use('/api/issues', bmIssuesRouter);
   app.use('/api/hgnform', hgnFormResponseRouter);
+  app.use('/api/progress', progressRouter);
   app.use('/api/skills', userSkillTabsRouter);
   app.use('/api/questionnaire-analytics/', questionnaireAnalyticsRouter);
   app.use('/api/applicant-analytics/', applicantAnalyticsRouter);
