Frontend account activation

backend/src/controllers/attendance.ts

@@ -2,6 +2,8 @@ import { validationResult } from "express-validator";
 import { Types } from "mongoose";
 
 import { AttendanceModel } from "../models/attendance";
+import { Section } from "../models/sections";
+import { SessionModel } from "../models/session";
 
 import type { RequestHandler } from "express";
 
@@ -54,6 +56,37 @@ export const updateAttendanceById: RequestHandler = async (req, res, next) => {
   }
 };
 
+const getStudentsInSection = async (sectionId: Types.ObjectId): Promise<Types.ObjectId[]> => {
+  const section = await Section.findById(sectionId).select("enrolledStudents");
+
+  // Can't be null because of validation checks prior to calling this function
+  return section!.enrolledStudents;
+};
+
+export const ensureAttendanceForSession = async (sessionId: string) => {
+  const existing = await AttendanceModel.find({ session: sessionId });
+  if (existing.length > 0) return existing;
+
+  const session = await SessionModel.findById(sessionId);
+  if (!session) throw new Error("Session not found");
+
+  const sessionDate = new Date(session.sessionDate);
+  const today = new Date();
+  sessionDate.setHours(0, 0, 0, 0);
+  today.setHours(0, 0, 0, 0);
+  // Don't create attendance for future sessions
+  if (sessionDate > today) return [];
+
+  const students = await getStudentsInSection(session.section);
+  await Promise.all(
+    students.map(async (studentId) =>
+      AttendanceModel.create({ session: session._id, student: studentId, status: "PRESENT" }),
+    ),
+  );
+
+  return AttendanceModel.find({ session: sessionId });
+};
+
 export const getAttendanceBySessionId: RequestHandler = async (req, res, next) => {
   try {
     const errors = validationResult(req);

backend/src/controllers/session.ts

@@ -1,18 +1,11 @@
 import { validationResult } from "express-validator";
 
 import { AttendanceModel } from "../models/attendance";
-import { Section } from "../models/sections";
 import { SessionModel } from "../models/session";
 
-import type { RequestHandler } from "express";
-import type { Types } from "mongoose";
-
-const getStudentsInSection = async (sectionId: string): Promise<Types.ObjectId[]> => {
-  const section = await Section.findById(sectionId).select("enrolledStudents");
+import { ensureAttendanceForSession } from "./attendance";
 
-  // Can't be null because of validation checks prior to calling this function
-  return section!.enrolledStudents;
-};
+import type { RequestHandler } from "express";
 
 type CreateSessionBody = {
   section: string;
@@ -30,22 +23,6 @@ export const createSession: RequestHandler = async (req, res, next) => {
       sessionDate,
     });
 
-    // create Attendance records for all students enrolled in Section
-
-    // Get all student Ids in the section (enrolledStudents list)
-    const students = await getStudentsInSection(section);
-
-    // Create attendance records for all students in session
-    await Promise.all(
-      students.map(async (studentId) =>
-        AttendanceModel.create({
-          session: session._id,
-          student: studentId,
-          status: "PRESENT",
-        }),
-      ),
-    );
-
     return res.status(201).json(session);
   } catch (error) {
     next(error);
@@ -87,14 +64,13 @@ export const getSession: RequestHandler = async (req, res, next) => {
       return res.status(404).json({ error: "Session not found" });
     }
 
-    // Check what we are searching for in the Attendance collection
-    const query = { session: id };
-    // Run the query
-    const attendanceRecords = await AttendanceModel.find(query).populate("student");
+    // This creates records if missing, checks the date, returns them
+    const attendanceRecords = await ensureAttendanceForSession(id);
+    const populated = await AttendanceModel.populate(attendanceRecords, { path: "student" });
 
     const response = {
       ...session.toObject(),
-      attendees: attendanceRecords,
+      attendees: populated,
     };
 
     res.status(200).json(response);
@@ -103,6 +79,21 @@ export const getSession: RequestHandler = async (req, res, next) => {
   }
 };
 
+// Returns all Sessions under a specific Section ID
+export const getSessionsBySectionId: RequestHandler = async (req, res, next) => {
+  const { sectionId } = req.params;
+
+  try {
+    const sessions = await SessionModel.find({ section: sectionId });
+
+    // No population of attendance records needed
+
+    res.status(200).json(sessions);
+  } catch (error) {
+    next(error);
+  }
+};
+
 export const getAllSessions: RequestHandler = async (req, res, next) => {
   try {
     const sessions = await SessionModel.find().populate("section");

backend/src/controllers/user.ts

@@ -1,5 +1,6 @@
 import { validationResult } from "express-validator";
 import { FirebaseAuthError } from "firebase-admin/auth";
+import { Types } from "mongoose";
 
 import UserModel from "../models/user";
 import { firebaseAdminAuth } from "../util/firebase";
@@ -13,13 +14,16 @@ type CreateUserBody = {
   lastName: string;
   personalEmail: string;
   meemliEmail: string;
+  phoneNumber: string;
   admin: boolean;
+  assignedSections?: string[];
 };
 
 export const createUser: RequestHandler = async (req, res, next) => {
   const errors = validationResult(req);
 
-  const { firstName, lastName, personalEmail, meemliEmail, admin } = req.body as CreateUserBody;
+  const { firstName, lastName, personalEmail, meemliEmail, phoneNumber, admin, assignedSections } =
+    req.body as CreateUserBody;
 
   try {
     validationErrorParser(errors);
@@ -32,13 +36,17 @@ export const createUser: RequestHandler = async (req, res, next) => {
         return userRecord;
       });
 
+    const assignedSectionsIds = assignedSections?.map((section) => new Types.ObjectId(section));
+
     const user = await UserModel.create({
       _id: userFirebase.uid,
       firstName,
       lastName,
       personalEmail,
       meemliEmail,
+      phoneNumber,
       admin,
+      assignedSections: assignedSectionsIds,
     });
 
     res.status(201).json(user);

backend/src/models/sections.ts

@@ -26,8 +26,7 @@ const sectionSchema = new mongoose.Schema(
       required: true, // Must be associated with a program
     },
     teachers: {
-      type: [mongoose.Schema.Types.ObjectId],
-      ref: "User", // Reference to the User model
+      type: [String],
       required: true, // Must contain at least one teacher
       default: [], // Default to an empty array if no teachers are added
     },

backend/src/models/user.ts

@@ -17,7 +17,10 @@ const userSchema = new Schema({
   lastName: { type: String, required: true },
   personalEmail: { type: String, required: true },
   meemliEmail: { type: String, required: true },
+  phoneNumber: { type: String, required: true },
   admin: { type: Boolean, required: true },
+  archived: { type: Boolean, required: true, default: false },
+  assignedSections: [{ type: Schema.Types.ObjectId, ref: "Section" }],
 });
 
 type User = InferSchemaType<typeof userSchema>;

backend/src/routes/session.ts

@@ -6,6 +6,7 @@ import * as SessionValidator from "../validators/session";
 const router = express.Router();
 
 router.get("/", SessionController.getAllSessions);
+router.get("/section/:sectionId", SessionController.getSessionsBySectionId);
 router.get("/:id", SessionController.getSession);
 
 router.post("/", SessionValidator.createSession, SessionController.createSession);

backend/src/scripts/createAdmin.ts

@@ -0,0 +1,31 @@
+// To run:
+// cd backend
+// npx ts-node src/scripts/createAdmin.ts
+import mongoose from "mongoose";
+
+import UserModel from "../models/user";
+import { firebaseAdminAuth } from "../util/firebase";
+
+async function createAdmin() {
+  await mongoose.connect(process.env.MONGO_URI!);
+
+  const firebaseUser = await firebaseAdminAuth.createUser({
+    email: "<test@gmail.com>",
+    password: "password",
+  });
+
+  const user = await UserModel.create({
+    _id: firebaseUser.uid,
+    firstName: "Admin",
+    lastName: "User",
+    personalEmail: "<test@gmail.com>",
+    meemliEmail: "<test@gmail.com>",
+    phoneNumber: "1234567890",
+    admin: true,
+  });
+
+  console.info("Admin created:", user);
+  process.exit();
+}
+
+void createAdmin();

backend/src/validators/sections.ts

@@ -14,7 +14,7 @@ const validateProgram = body("program")
 
 export const validateTeachers: ValidationChain[] = [
   body("teachers").isArray().withMessage("Teachers must be an array"),
-  body("teachers.*").isMongoId().withMessage("Each teacher must be a valid MongoDB ObjectID"),
+  body("teachers.*").isString().withMessage("Each teacher must be a string").bail(),
 ];
 
 export const validateEnrolledStudents: ValidationChain[] = [

backend/src/validators/user.ts

@@ -1,4 +1,5 @@
 import { body } from "express-validator";
+import { Types } from "mongoose";
 
 import type { ValidationChain } from "express-validator";
 
@@ -44,6 +45,18 @@ const makeMeemliEmailValidator = (): ValidationChain => {
     .withMessage("meemliEmail must be a valid email");
 };
 
+const makePhoneNumberValidator = (): ValidationChain => {
+  return body("phoneNumber")
+    .exists()
+    .withMessage("phoneNumber is required")
+    .bail()
+    .isString()
+    .withMessage("phoneNumber must be a string")
+    .bail()
+    .matches(/^\d{10}$/)
+    .withMessage("phoneNumber must be a valid 10-digit number");
+};
+
 const makeAdminValidator = (): ValidationChain => {
   return body("admin")
     .exists()
@@ -53,18 +66,36 @@ const makeAdminValidator = (): ValidationChain => {
     .withMessage("admin must be a boolean");
 };
 
+const makeAssignedSectionsValidator = (): ValidationChain => {
+  return body("assignedSections")
+    .exists()
+    .withMessage("assignedSections is required")
+    .bail()
+    .isArray()
+    .withMessage("assignedSections must be an array")
+    .bail()
+    .custom((value: string[]) => {
+      return value.every((section) => Types.ObjectId.isValid(new Types.ObjectId(section)));
+    })
+    .withMessage("assignedSections must contain valid ObjectId strings");
+};
+
 export const validateCreateUser = [
   makeFirstNameValidator(),
   makeLastNameValidator(),
   makePersonalEmailValidator(),
   makeMeemliEmailValidator(),
+  makePhoneNumberValidator(),
   makeAdminValidator(),
+  makeAssignedSectionsValidator(),
 ];
 
 export const validateEditUser = [
   makeFirstNameValidator().optional(),
   makeLastNameValidator().optional(),
   makePersonalEmailValidator().optional(),
   makeMeemliEmailValidator().optional(),
+  makePhoneNumberValidator().optional(),
   makeAdminValidator().optional(),
+  makeAssignedSectionsValidator().optional(),
 ];