feature/lisasiliu/view-student-profile-v2

backend/src/controllers/image.ts

@@ -0,0 +1,74 @@
+/**
+ * Functions that process image route requests.
+ */
+
+import { NextFunction, Request, Response } from "express";
+import mongoose from "mongoose";
+
+import { InternalError } from "../errors";
+import { ServiceError } from "../errors/service";
+import { ValidationError } from "../errors/validation";
+import { Image } from "../models/image";
+import StudentModel from "../models/student";
+import UserModel from "../models/user";
+import { handleImageParsing } from "../util/image";
+
+import { OwnerRequestBody } from "./types/types";
+import { EditPhotoRequestBody } from "./types/userTypes";
+
+export const editPhoto = (req: EditPhotoRequestBody, res: Response, nxt: NextFunction) => {
+  try {
+    //Validation logic inside handleImageParsing
+    handleImageParsing(req, res, nxt);
+  } catch (e) {
+    console.log(e);
+    nxt(e);
+  }
+};
+
+export const getPhoto = async (
+  req: Request<Record<string, never>, Record<string, never>, OwnerRequestBody>,
+  res: Response,
+  nxt: NextFunction,
+) => {
+  try {
+    const { ownerId, ownerType, imageId } = req.body;
+
+    if (!mongoose.Types.ObjectId.isValid(imageId)) {
+      return res
+        .status(ValidationError.INVALID_MONGO_ID.status)
+        .send({ error: ValidationError.INVALID_MONGO_ID.message });
+    }
+
+    let owner = null;
+
+    if (ownerType === "user") {
+      owner = await UserModel.findById(ownerId);
+    } else if (ownerType === "student") {
+      owner = await StudentModel.findById(ownerId);
+    }
+
+    if (!owner) {
+      throw ValidationError.USER_NOT_FOUND;
+    }
+
+    const image = await Image.findById(imageId);
+    if (!image) {
+      throw ValidationError.IMAGE_NOT_FOUND;
+    }
+
+    if (image.ownerId !== ownerId) {
+      throw ValidationError.IMAGE_USER_MISMATCH;
+    }
+
+    return res.status(200).set("Content-type", image.mimetype).send(image.buffer);
+  } catch (e) {
+    console.log(e);
+    if (e instanceof ServiceError) {
+      nxt(e);
+    }
+    return res
+      .status(InternalError.ERROR_GETTING_IMAGE.status)
+      .send(InternalError.ERROR_GETTING_IMAGE.displayMessage(true));
+  }
+};

backend/src/controllers/student.ts

@@ -8,6 +8,8 @@ import { validationResult } from "express-validator";
 import mongoose, { HydratedDocument } from "mongoose";
 
 import EnrollmentModel from "../models/enrollment";
+import { Image } from "../models/image";
+import ProgressNoteModel from "../models/progressNote";
 import StudentModel from "../models/student";
 import { Enrollment } from "../types/enrollment";
 import { createEnrollment, editEnrollment } from "../util/enrollment";
@@ -22,16 +24,25 @@ export const createStudent: RequestHandler = async (req, res, next) => {
 
     validationErrorParser(errors);
 
+    const newStudentId = new mongoose.Types.ObjectId();
+
     const { enrollments, ...studentData } = req.body as StudentRequest;
-    const newStudent = await StudentModel.create(studentData);
+
     // create enrollments for the student
-    await Promise.all(
+    const createdEnrollments = await Promise.all(
       enrollments.map(async (program: Enrollment) => {
-        await createEnrollment({ ...program, studentId: newStudent._id });
+        return await EnrollmentModel.create({ ...program, studentId: newStudentId });
       }),
     );
 
-    res.status(201).json(newStudent);
+    const newStudent = await StudentModel.create({
+      ...studentData,
+      enrollments: createdEnrollments.map((enrollment) => enrollment._id),
+    });
+
+    const populatedStudent = await StudentModel.findById(newStudent._id).populate("enrollments");
+
+    res.status(201).json(populatedStudent);
   } catch (error) {
     next(error);
   }
@@ -49,42 +60,106 @@ export const editStudent: RequestHandler = async (req, res, next) => {
     if (studentId !== studentData._id.toString()) {
       return res.status(400).json({ message: "Invalid student ID" });
     }
-    const updatedStudent = await StudentModel.findByIdAndUpdate(studentId, studentData, {
-      new: true,
-    });
-    if (!updatedStudent) {
-      return res.status(404).json({ message: "Student not found" });
+
+    if (!enrollments) {
+      const updatedStudent = await StudentModel.findByIdAndUpdate(
+        studentId,
+        { ...studentData },
+        {
+          new: true,
+        },
+      );
+      if (!updatedStudent) {
+        return res.status(404).json({ message: "Student not found" });
+      }
+
+      return res.status(200).json(updatedStudent);
     }
 
     // update enrollments for the student
-    await Promise.all(
+    const updatedEnrollments = await Promise.all(
       enrollments.map(async (enrollment: Enrollment) => {
         const enrollmentExists = await EnrollmentModel.findById(enrollment._id);
         const enrollmentBody = { ...enrollment, studentId: new mongoose.Types.ObjectId(studentId) };
-        if (!enrollmentExists) await createEnrollment(enrollmentBody);
-        else await editEnrollment(enrollmentBody);
+        if (!enrollmentExists) {
+          return await createEnrollment(enrollmentBody);
+        } else {
+          return await editEnrollment(enrollmentBody);
+        }
       }),
     );
 
-    res.status(200).json({ ...updatedStudent, enrollments });
+    const updatedStudent = await StudentModel.findByIdAndUpdate(
+      studentId,
+      { ...studentData, enrollments: updatedEnrollments.map((enrollment) => enrollment?._id) },
+      {
+        new: true,
+      },
+    );
+    if (!updatedStudent) {
+      return res.status(404).json({ message: "Student not found" });
+    }
+
+    const populatedStudent = await StudentModel.findById(updatedStudent._id).populate(
+      "enrollments",
+    );
+
+    console.log({ populatedStudent });
+
+    res.status(200).json(populatedStudent);
   } catch (error) {
     next(error);
   }
 };
 
 export const getAllStudents: RequestHandler = async (_, res, next) => {
   try {
-    const students = await StudentModel.find();
+    const students = await StudentModel.find().populate("enrollments");
 
-    // gather all enrollments for each student and put them in student.programs
-    const hydratedStudents = await Promise.all(
-      students.map(async (student) => {
-        const enrollments = await EnrollmentModel.find({ studentId: student._id });
-        return { ...student.toObject(), programs: enrollments };
-      }),
-    );
+    res.status(200).json(students);
+  } catch (error) {
+    next(error);
+  }
+};
+
+export const getStudent: RequestHandler = async (req, res, next) => {
+  try {
+    const errors = validationResult(req);
+
+    validationErrorParser(errors);
+
+    const studentId = req.params.id;
+    const studentData = await StudentModel.findById(req.params.id);
+
+    if (!studentData) {
+      return res.status(404).json({ message: "Student not found" });
+    }
+
+    const enrollments = await EnrollmentModel.find({ studentId });
+
+    res.status(200).json({ ...studentData.toObject(), enrollments });
+  } catch (error) {
+    next(error);
+  }
+};
+
+export const deleteStudent: RequestHandler = async (req, res, next) => {
+  try {
+    const errors = validationResult(req);
+    validationErrorParser(errors);
+
+    const studentId = req.params.id;
+    const deletedStudent = await StudentModel.findById(studentId);
+    if (!deletedStudent) {
+      return res.status(404).json({ message: "Student not found" });
+    }
+
+    await EnrollmentModel.deleteMany({ studentId });
+    await ProgressNoteModel.deleteMany({ studentId });
+    await Image.deleteMany({ userId: studentId });
+    await StudentModel.deleteOne({ _id: studentId });
 
-    res.status(200).json(hydratedStudents);
+    res.status(200).json(deletedStudent);
   } catch (error) {
     next(error);
   }

backend/src/controllers/types/types.ts

@@ -5,3 +5,21 @@ export type UserId = {
 };
 
 export type UserIdRequestBody = Request & UserId;
+
+// Add type so that if uploadType is "create", new field imgeId is required
+type NewUploadType = {
+  uploadType: "new";
+  imageId: string;
+};
+
+type EditUploadType = {
+  uploadType: "edit";
+  imageId: never;
+};
+
+export type OwnerInfo = {
+  ownerId: string;
+  ownerType: string;
+} & (NewUploadType | EditUploadType);
+
+export type OwnerRequestBody = Request & OwnerInfo;

backend/src/controllers/types/userTypes.ts

@@ -1,6 +1,6 @@
 import { Request } from "express";
 
-import { UserId } from "./types";
+import { OwnerInfo, UserId } from "./types";
 
 export type CreateUserRequestBody = {
   name: string;
@@ -32,7 +32,10 @@ export type UpdateAccountTypeRequestBody = UserId & {
 export type SaveImageRequest = {
   body: {
     previousImageId: string;
-    userId: string;
+    ownerId: string;
+    ownerType: string;
+    uploadType: string;
+    imageId: string;
   };
   file: {
     buffer: Buffer;
@@ -42,6 +45,10 @@ export type SaveImageRequest = {
   };
 };
 
-export type EditPhotoRequestBody = Request<Record<string, never>, Record<string, never>, UserId> & {
+export type EditPhotoRequestBody = Request<
+  Record<string, never>,
+  Record<string, never>,
+  OwnerInfo
+> & {
   rawBody?: Buffer;
 };

backend/src/controllers/user.ts

@@ -1,16 +1,11 @@
 import { NextFunction, Request, Response } from "express";
 import { validationResult } from "express-validator";
 import admin from "firebase-admin";
-import mongoose from "mongoose";
 
-import { InternalError } from "../errors";
-import { ServiceError } from "../errors/service";
 import { ValidationError } from "../errors/validation";
-import { Image } from "../models/image";
 import UserModel from "../models/user";
 import { sendApprovalEmail, sendDenialEmail } from "../util/email";
 import { firebaseAdminAuth } from "../util/firebase";
-import { handleImageParsing } from "../util/image";
 import { deleteUserFromFirebase, deleteUserFromMongoDB } from "../util/user";
 import validationErrorParser from "../util/validationErrorParser";
 
@@ -20,7 +15,6 @@
   EditEmailRequestBody,
   EditLastChangedPasswordRequestBody,
   EditNameRequestBody,
-  EditPhotoRequestBody,
   LoginUserRequestBody,
   UpdateAccountTypeRequestBody,
 } from "./types/userTypes";
@@ -100,9 +94,9 @@
 
 export const approveUser = async (req: Request, res: Response, nxt: NextFunction) => {
   try {
     const { email } = req.body;
 
     const user = await UserModel.findOne({ email });
     if (!user) {
       return res.status(404).send("User not found");
     }
@@ -125,12 +119,12 @@
   console.log("Inside denyUser controller");
 
   try {
     const { email } = req.body;
 
     console.log("Email from request body:", email);
 
     // const user = await UserModel.findOne({ email });
     const user = await UserModel.findOne({ email });
 
     if (!user) {
       return res.status(404).send("User not found");
@@ -174,57 +168,6 @@
   }
 };
 
-export const editPhoto = (req: EditPhotoRequestBody, res: Response, nxt: NextFunction) => {
-  try {
-    //Validation logic inside handleImageParsing
-    handleImageParsing(req, res, nxt);
-  } catch (e) {
-    console.log(e);
-    nxt(e);
-  }
-};
-
-export const getPhoto = async (
-  req: Request<Record<string, never>, Record<string, never>, UserIdRequestBody>,
-  res: Response,
-  nxt: NextFunction,
-) => {
-  try {
-    const { uid } = req.body;
-    const { id: imageId } = req.params;
-
-    if (!mongoose.Types.ObjectId.isValid(imageId)) {
-      return res
-        .status(ValidationError.INVALID_MONGO_ID.status)
-        .send({ error: ValidationError.INVALID_MONGO_ID.message });
-    }
-
-    const user = await UserModel.findById(uid);
-    if (!user) {
-      throw ValidationError.USER_NOT_FOUND;
-    }
-
-    const image = await Image.findById(imageId);
-    if (!image) {
-      throw ValidationError.IMAGE_NOT_FOUND;
-    }
-
-    if (image.userId !== uid) {
-      throw ValidationError.IMAGE_USER_MISMATCH;
-    }
-
-    return res.status(200).set("Content-type", image.mimetype).send(image.buffer);
-  } catch (e) {
-    console.log(e);
-    if (e instanceof ServiceError) {
-      nxt(e);
-    }
-    return res
-      .status(InternalError.ERROR_GETTING_IMAGE.status)
-      .send(InternalError.ERROR_GETTING_IMAGE.displayMessage(true));
-  }
-};
-
 export const editName = async (
   req: Request<Record<string, never>, Record<string, never>, EditNameRequestBody>,
   res: Response,

backend/src/errors/validation.ts

@@ -11,6 +11,7 @@ const IMAGE_NOT_FOUND = "Image was not found. Please make sure id passed in rout
 const INVALID_MONGO_ID = "Mongo ID was invalid. Please ensure that the id is correct";
 const IMAGE_USER_MISMATCH = "Image does not belong to the user";
 const PROGRESS_NOTE_NOT_FOUND = "Progress note not found in database";
+const IMAGE_UPDATED_FAILED = "Image was not updated successfully";
 
 export class ValidationError extends CustomError {
   static USER_CREATION_UNSUCCESSFUL = new ValidationError(1, 400, USER_CREATION_UNSUCCESSFUL);
@@ -24,4 +25,5 @@ export class ValidationError extends CustomError {
   static INVALID_MONGO_ID = new ValidationError(9, 400, INVALID_MONGO_ID);
   static IMAGE_USER_MISMATCH = new ValidationError(10, 401, IMAGE_USER_MISMATCH);
   static PROGRESS_NOTE_NOT_FOUND = new ValidationError(11, 404, PROGRESS_NOTE_NOT_FOUND);
+  static IMAGE_UPDATED_FAILED = new ValidationError(12, 400, IMAGE_UPDATED_FAILED);
 }