Add New Assessment Framework

backend/app.ts

@@ -7,6 +7,7 @@ import setupJiraJob from './jobs/jiraJob';
 import setupTrofosJob from './jobs/trofosJob';
 import accountRoutes from './routes/accountRoutes';
 import assessmentRoutes from './routes/assessmentRoutes';
+import internalAssessmentRoutes from './routes/internalAssessmentRoutes';
 import courseRoutes from './routes/courseRoutes';
 import githubRoutes from './routes/githubRoutes';
 import jiraRoutes from './routes/jiraRoutes';
@@ -16,6 +17,9 @@ import teamSetRoutes from './routes/teamSetRoutes';
 import userRoutes from './routes/userRoutes';
 import codeAnalysisRoutes from './routes/codeAnalysisRoutes';
 import { connectToDatabase } from './utils/database';
+import submissionRoutes from 'routes/submissionRoutes';
+import assessmentAssignmentSetRoutes from 'routes/assessmentAssignmentSetRoutes';
+import assessmentResultRoutes from 'routes/assessmentResultRoutes';
 
 const env = process.env.NODE_ENV ?? 'development';
 config({ path: `.env.${env}` });
@@ -42,9 +46,13 @@ app.use('/api/accounts', accountRoutes);
 app.use('/api/teams', teamRoutes);
 app.use('/api/teamsets', teamSetRoutes);
 app.use('/api/assessments', assessmentRoutes);
+app.use('/api/internal-assessments', internalAssessmentRoutes);
+app.use('/api/submissions', submissionRoutes);
 app.use('/api/jira', jiraRoutes);
 app.use('/api/metrics', metricRoutes);
 app.use('/api/user', userRoutes);
+app.use('/api/assessment-results', assessmentResultRoutes);
+app.use('/api/assignment-sets', assessmentAssignmentSetRoutes);
 app.use('/api/codeanalysis', codeAnalysisRoutes);
 
 app.listen(port, () => {

backend/controllers/assessmentAssignmentSetController.ts

@@ -0,0 +1,156 @@
+// controllers/assessmentAssignmentSetController.ts
+
+import { Request, Response } from 'express';
+import {
+  createAssignmentSet,
+  getAssignmentSetByAssessmentId,
+  updateAssignmentSet,
+  getAssignmentsByTAId,
+  getUnmarkedAssignmentsByTAId,
+} from '../services/assessmentAssignmentSetService';
+import { BadRequestError, NotFoundError } from '../services/errors';
+import { getAccountId } from '../utils/auth';
+import { getUserIdByAccountId } from '../services/accountService';
+
+/**
+ * Controller to create a new AssessmentAssignmentSet.
+ */
+export const createAssignmentSetController = async (
+  req: Request,
+  res: Response
+) => {
+  const { assessmentId } = req.params;
+  const { originalTeamSetId } = req.body;
+
+  // Validate input
+  if (!originalTeamSetId) {
+    return res.status(400).json({ error: 'originalTeamSetId is required' });
+  }
+
+  try {
+    const assignmentSet = await createAssignmentSet(
+      assessmentId,
+      originalTeamSetId
+    );
+    res.status(201).json(assignmentSet);
+  } catch (error) {
+    if (error instanceof BadRequestError || error instanceof NotFoundError) {
+      res.status(400).json({ error: error.message });
+    } else {
+      console.error('Error creating AssessmentAssignmentSet:', error);
+      res
+        .status(500)
+        .json({ error: 'Failed to create AssessmentAssignmentSet' });
+    }
+  }
+};
+
+/**
+ * Controller to retrieve an AssessmentAssignmentSet by assessment ID.
+ */
+export const getAssignmentSetController = async (
+  req: Request,
+  res: Response
+) => {
+  const { assessmentId } = req.params;
+
+  try {
+    const assignmentSet = await getAssignmentSetByAssessmentId(assessmentId);
+    res
+      .status(200)
+      .json(
+        assignmentSet.assignedTeams === null
+          ? assignmentSet.assignedUsers
+          : assignmentSet.assignedTeams
+      );
+  } catch (error) {
+    if (error instanceof NotFoundError) {
+      res.status(404).json({ error: error.message });
+    } else {
+      console.error('Error fetching AssessmentAssignmentSet:', error);
+      res
+        .status(500)
+        .json({ error: 'Failed to fetch AssessmentAssignmentSet' });
+    }
+  }
+};
+
+/**
+ * Controller to update the assignedTeams within an AssessmentAssignmentSet.
+ */
+export const updateAssignmentSetController = async (
+  req: Request,
+  res: Response
+) => {
+  const { assessmentId } = req.params;
+  const { assignedTeams, assignedUsers } = req.body;
+
+  try {
+    const updatedSet = await updateAssignmentSet(
+      assessmentId,
+      assignedTeams,
+      assignedUsers
+    );
+    res.status(200).json(updatedSet);
+  } catch (error) {
+    if (error instanceof NotFoundError || error instanceof BadRequestError) {
+      res.status(400).json({ error: error.message });
+    } else {
+      console.error('Error updating AssessmentAssignmentSet:', error);
+      res
+        .status(500)
+        .json({ error: 'Failed to update AssessmentAssignmentSet' });
+    }
+  }
+};
+
+/**
+ * Controller to retrieve all teams assigned to a specific TA within an assessment.
+ */
+export const getAssignmentsByTAIdController = async (
+  req: Request,
+  res: Response
+) => {
+  const { assessmentId } = req.params;
+  const accountId = await getAccountId(req);
+  const userId = await getUserIdByAccountId(accountId);
+
+  try {
+    const assignments = await getAssignmentsByTAId(userId, assessmentId);
+    res.status(200).json(assignments);
+  } catch (error) {
+    if (error instanceof NotFoundError) {
+      res.status(404).json({ error: error.message });
+    } else {
+      console.error('Error fetching assignments by TA:', error);
+      res.status(500).json({ error: 'Failed to fetch assignments by TA' });
+    }
+  }
+};
+
+/**
+ * Controller to retrieve all unmarked teams assigned to a specific TA within an assessment.
+ */
+export const getUnmarkedAssignmentsByTAIdController = async (
+  req: Request,
+  res: Response
+) => {
+  const { assessmentId } = req.params;
+  const accountId = await getAccountId(req);
+  const userId = await getUserIdByAccountId(accountId);
+
+  try {
+    const assignments = await getUnmarkedAssignmentsByTAId(
+      userId,
+      assessmentId
+    );
+    res.status(200).json(assignments);
+  } catch (error) {
+    if (error instanceof NotFoundError) {
+      res.status(404).json({ error: error.message });
+    } else {
+      console.error('Error fetching assignments by TA:', error);
+      res.status(500).json({ error: 'Failed to fetch assignments by TA' });
+    }
+  }
+};

backend/controllers/assessmentResultController.ts

@@ -0,0 +1,164 @@
+/* eslint-disable @typescript-eslint/no-explicit-any */
+import { Request, Response } from 'express';
+import {
+  getOrCreateAssessmentResults,
+  recalculateResult,
+} from '../services/assessmentResultService';
+import { BadRequestError, NotFoundError } from '../services/errors';
+import { getAssignmentSetByAssessmentId } from '../services/assessmentAssignmentSetService';
+import { getAccountId } from '../utils/auth';
+import { getInternalAssessmentById } from '../services/internalAssessmentService';
+import TeamModel from '@models/Team';
+
+/**
+ * Controller to retrieve or create AssessmentResults for an assessment.
+ * Route: GET /api/assessment-results/:assessmentId
+ */
+export const getOrCreateAssessmentResultsController = async (
+  req: Request,
+  res: Response
+) => {
+  const { assessmentId } = req.params;
+  const accountId = await getAccountId(req);
+
+  try {
+    const assessment = await getInternalAssessmentById(assessmentId, accountId);
+    if (!assessment) {
+      throw new NotFoundError('Assessment not found');
+    }
+
+    const assignmentSet = await getAssignmentSetByAssessmentId(assessmentId);
+    if (!assignmentSet) {
+      throw new NotFoundError('Assignment Set not found for this assessment');
+    }
+
+    const assessmentResults = await getOrCreateAssessmentResults(assessmentId);
+    if (!assessmentResults) {
+      throw new NotFoundError(
+        'Assessment Results not found for this assessment'
+      );
+    }
+
+    const assessmentResultMap = new Map<string, any>();
+
+    assessmentResults.forEach(result => {
+      assessmentResultMap.set(result.student._id.toString(), result);
+    });
+
+    if (assessment.granularity === 'individual') {
+      if (!assignmentSet.assignedUsers) {
+        throw new BadRequestError(
+          'Assessment is individual granularity, but assignments are for teams'
+        );
+      }
+      for (const assignedUser of assignmentSet.assignedUsers) {
+        const studentId = assignedUser.user._id.toString();
+        let assessmentResult = assessmentResultMap.get(studentId);
+        if (!assessmentResult) {
+          assessmentResult = {
+            _id: 'temp-' + studentId,
+            assessment: assessmentId,
+            student: assignedUser.user,
+            marks: [],
+          };
+        }
+        for (const marker of assignedUser.tas) {
+          const existingMarkEntry = assessmentResult.marks.find(
+            (markEntry: any) =>
+              markEntry.marker._id.toString() === marker._id.toString()
+          );
+          if (!existingMarkEntry) {
+            const tempMarkEntry = {
+              marker: marker,
+              submission: null,
+              score: null,
+            };
+            assessmentResult.marks.push(tempMarkEntry);
+          }
+        }
+        assessmentResultMap.set(studentId, assessmentResult);
+      }
+    } else if (assessment.granularity === 'team') {
+      if (!assignmentSet.assignedTeams) {
+        throw new BadRequestError(
+          'Assessment is team granularity, but assignments are for users'
+        );
+      }
+      for (const assignedTeam of assignmentSet.assignedTeams) {
+        const teamId = assignedTeam.team._id.toString();
+        const team = await TeamModel.findById(teamId).populate('members');
+        if (!team || !team.members || team.members.length === 0) {
+          continue;
+        }
+        team.members.forEach(member => {
+          const studentId = member._id.toString();
+          let assessmentResult = assessmentResultMap.get(studentId);
+          if (!assessmentResult) {
+            assessmentResult = {
+              _id: 'temp-team-' + studentId,
+              assessment: assessmentId,
+              team: assignedTeam.team,
+              marks: [],
+            };
+          }
+          for (const marker of assignedTeam.tas) {
+            const existingMarkEntry = assessmentResult.marks.find(
+              (markEntry: any) =>
+                markEntry.marker._id.toString() === marker._id.toString()
+            );
+            if (!existingMarkEntry) {
+              const tempMarkEntry = {
+                marker: marker,
+                submission: null,
+                score: null,
+              };
+              assessmentResult.marks.push(tempMarkEntry);
+            }
+          }
+          assessmentResultMap.set(studentId, assessmentResult);
+        });
+      }
+    }
+
+    const updatedAssessmentResults = Array.from(assessmentResultMap.values());
+
+    res.json({ data: updatedAssessmentResults });
+  } catch (error) {
+    if (error instanceof BadRequestError) {
+      res.status(400).json({ error: error.message });
+    } else if (error instanceof NotFoundError) {
+      res.status(404).json({ error: error.message });
+    } else {
+      console.error('Error retrieving or creating AssessmentResults:', error);
+      res
+        .status(500)
+        .json({ error: 'Failed to retrieve or create AssessmentResults' });
+    }
+  }
+};
+
+/**
+ * Controller to recalculate the average score of an AssessmentResult.
+ * Route: POST /api/assessment-results/:resultId/recalculate
+ */
+export const recalculateResultController = async (
+  req: Request,
+  res: Response
+) => {
+  const { resultId } = req.params;
+
+  try {
+    await recalculateResult(resultId);
+    res.status(200).json({
+      success: true,
+      message: 'Average score recalculated successfully.',
+    });
+  } catch (error) {
+    if (error instanceof NotFoundError) {
+      res.status(404).json({ error: error.message });
+    } else {
+      console.error('Error recalculating AssessmentResult:', error);
+      res.status(500).json({ error: 'Failed to recalculate AssessmentResult' });
+    }
+  }
+};