fix merge conflicts

backend/src/routes/program.ts

@@ -5,15 +5,26 @@
 import express from "express"; // { RequestHandler }
 
 import * as ProgramController from "../controllers/program";
+import { verifyAuthToken } from "../validators/auth";
 import * as ProgramValidator from "../validators/program";
 
 const router = express.Router();
 
-router.patch("/:id", ProgramValidator.updateProgram, ProgramController.updateProgram);
-router.post("/create", ProgramValidator.createProgram, ProgramController.createProgram);
-router.post("/archive/:id", ProgramController.archiveProgram);
-router.get("/all", ProgramController.getAllPrograms);
-router.get("/:id", ProgramController.getProgram);
-router.get("/enrollments/:id", ProgramController.getProgramEnrollments);
+router.patch(
+  "/:id",
+  [verifyAuthToken],
+  ProgramValidator.updateProgram,
+  ProgramController.updateProgram,
+);
+router.post(
+  "/create",
+  [verifyAuthToken],
+  ProgramValidator.createProgram,
+  ProgramController.createProgram,
+);
+router.post("/archive/:id", [verifyAuthToken], ProgramController.archiveProgram);
+router.get("/all", [verifyAuthToken], ProgramController.getAllPrograms);
+router.get("/:id", [verifyAuthToken], ProgramController.getProgram);
+router.get("/enrollments/:id", [verifyAuthToken], ProgramController.getProgramEnrollments);
 
 export default router;

backend/src/routes/session.ts

@@ -5,15 +5,22 @@
 import express from "express";
 
 import * as SessionController from "../controllers/session";
+import { verifyAuthToken } from "../validators/auth";
 import * as SessionValidator from "../validators/session";
 
 const router = express.Router();
 
-router.get("/get", SessionController.getRecentSessions);
-router.get("/getAbsences", SessionController.getAbsenceSessions);
-router.patch("/mark", SessionValidator.updateSession, SessionController.updateSession);
+router.get("/get", [verifyAuthToken], SessionController.getRecentSessions);
+router.get("/getAbsences", [verifyAuthToken], SessionController.getAbsenceSessions);
+router.patch(
+  "/mark",
+  [verifyAuthToken],
+  SessionValidator.updateSession,
+  SessionController.updateSession,
+);
 router.post(
   "/markAbsence",
+  [verifyAuthToken],
   SessionValidator.absenceSession,
   SessionController.createAbsenceSession,
 );

backend/src/routes/student.ts

@@ -9,8 +9,18 @@ import { verifyAuthToken } from "../validators/auth";
 import * as StudentValidator from "../validators/student";
 const router = express.Router();
 
-router.post("/create", StudentValidator.createStudent, StudentController.createStudent);
-router.put("/edit/:id", ...StudentValidator.editStudent, StudentController.editStudent);
+router.post(
+  "/create",
+  [verifyAuthToken],
+  StudentValidator.createStudent,
+  StudentController.createStudent,
+);
+router.put(
+  "/edit/:id",
+  [verifyAuthToken],
+  ...StudentValidator.editStudent,
+  StudentController.editStudent,
+);
 router.get("/all", [verifyAuthToken], StudentController.getAllStudents);
 router.get("/:id", [verifyAuthToken], StudentController.getStudent);
 router.delete("/:id", [verifyAuthToken], StudentController.deleteStudent);

frontend/src/api/programs.ts

@@ -1,6 +1,8 @@
 import { GET, PATCH, POST, handleAPIError } from "../api/requests";
 import { CreateProgramRequest } from "../components/ProgramForm/types";
 
+import { createAuthHeader } from "./progressNotes";
+
 import type { APIResult } from "../api/requests";
 
 export type Program = CreateProgramRequest & { _id: string; dateUpdated: string };
@@ -23,9 +25,13 @@ export type Enrollment = {
   authNumber: string;
 };
 
-export async function createProgram(program: CreateProgramRequest): Promise<APIResult<Program>> {
+export async function createProgram(
+  program: CreateProgramRequest,
+  firebaseToken: string,
+): Promise<APIResult<Program>> {
   try {
-    const response = await POST("/program/create", program);
+    const headers = createAuthHeader(firebaseToken);
+    const response = await POST("/program/create", program, headers);
     const json = (await response.json()) as Program;
     console.log({ json });
     return { success: true, data: json };
@@ -34,29 +40,38 @@ export async function createProgram(program: CreateProgramRequest): Promise<APIR
   }
 }
 
-export async function getProgram(id: string): Promise<APIResult<Program>> {
+export async function getProgram(id: string, firebaseToken: string): Promise<APIResult<Program>> {
   try {
-    const response = await GET(`/program/${id}`);
+    const headers = createAuthHeader(firebaseToken);
+    const response = await GET(`/program/${id}`, headers);
     const json = (await response.json()) as Program;
     return { success: true, data: json };
   } catch (error) {
     return handleAPIError(error);
   }
 }
 
-export async function getProgramEnrollments(id: string): Promise<APIResult<[Enrollment]>> {
+export async function getProgramEnrollments(
+  id: string,
+  firebaseToken: string,
+): Promise<APIResult<[Enrollment]>> {
   try {
-    const response = await GET(`/program/enrollments/${id}`);
+    const headers = createAuthHeader(firebaseToken);
+    const response = await GET(`/program/enrollments/${id}`, headers);
     const json = (await response.json()) as [Enrollment];
     return { success: true, data: json };
   } catch (error) {
     return handleAPIError(error);
   }
 }
 
-export async function editProgram(program: Program): Promise<APIResult<Program>> {
+export async function editProgram(
+  program: Program,
+  firebaseToken: string,
+): Promise<APIResult<Program>> {
   try {
-    const response = await PATCH(`/program/${program._id}`, program);
+    const headers = createAuthHeader(firebaseToken);
+    const response = await PATCH(`/program/${program._id}`, program, headers);
     const json = (await response.json()) as Program;
     console.log({ json });
     return { success: true, data: json };
@@ -65,19 +80,24 @@ export async function editProgram(program: Program): Promise<APIResult<Program>>
   }
 }
 
-export async function getAllPrograms(): Promise<APIResult<[Program]>> {
+export async function getAllPrograms(firebaseToken: string): Promise<APIResult<[Program]>> {
   try {
-    const response = await GET("/program/all");
+    const headers = createAuthHeader(firebaseToken);
+    const response = await GET("/program/all", headers);
     const json = (await response.json()) as [Program];
     return { success: true, data: json };
   } catch (error) {
     return handleAPIError(error);
   }
 }
 
-export async function archiveProgram(program: Program): Promise<APIResult<Program>> {
+export async function archiveProgram(
+  program: Program,
+  firebaseToken: string,
+): Promise<APIResult<Program>> {
   try {
-    const response = await POST(`/program/archive/${program._id}`, undefined);
+    const headers = createAuthHeader(firebaseToken);
+    const response = await POST(`/program/archive/${program._id}`, undefined, headers);
     const json = (await response.json()) as Program;
     return { success: true, data: json };
   } catch (error) {

frontend/src/api/sessions.ts

@@ -1,5 +1,7 @@
 import { GET, PATCH, POST, handleAPIError } from "../api/requests";
 
+import { createAuthHeader } from "./progressNotes";
+
 import type { APIResult } from "../api/requests";
 
 export type Session = {
@@ -33,29 +35,37 @@ export type AbsenceCreateBody = {
   };
 };
 
-export async function getRecentSessions(): Promise<APIResult<[Session]>> {
+export async function getRecentSessions(firebaseToken: string): Promise<APIResult<[Session]>> {
   try {
-    const response = await GET("/session/get");
+    const headers = createAuthHeader(firebaseToken);
+    const response = await GET("/session/get", headers);
     const json = (await response.json()) as [Session];
     return { success: true, data: json };
   } catch (error) {
     return handleAPIError(error);
   }
 }
 
-export async function getAbsenceSessions(): Promise<APIResult<[AbsenceSession]>> {
+export async function getAbsenceSessions(
+  firebaseToken: string,
+): Promise<APIResult<[AbsenceSession]>> {
   try {
-    const response = await GET("/session/getAbsences");
+    const headers = createAuthHeader(firebaseToken);
+    const response = await GET("/session/getAbsences", headers);
     const json = (await response.json()) as [AbsenceSession];
     return { success: true, data: json };
   } catch (error) {
     return handleAPIError(error);
   }
 }
 
-export async function updateSession(session: Session): Promise<APIResult<Session>> {
+export async function updateSession(
+  session: Session,
+  firebaseToken: string,
+): Promise<APIResult<Session>> {
   try {
-    const response = await PATCH(`/session/mark`, session);
+    const headers = createAuthHeader(firebaseToken);
+    const response = await PATCH(`/session/mark`, session, headers);
     const json = (await response.json()) as Session;
     return { success: true, data: json };
   } catch (error) {
@@ -65,9 +75,11 @@ export async function updateSession(session: Session): Promise<APIResult<Session
 
 export async function createAbsenceSession(
   session: AbsenceCreateBody,
+  firebaseToken: string,
 ): Promise<APIResult<Session>> {
   try {
-    const response = await POST(`/session/markAbsence`, session);
+    const headers = createAuthHeader(firebaseToken);
+    const response = await POST(`/session/markAbsence`, session, headers);
     const json = (await response.json()) as Session;
     return { success: true, data: json };
   } catch (error) {

frontend/src/api/students.ts

@@ -17,9 +17,13 @@ type EditStudentRequest = {
   _id: string;
 } & Partial<Student>;
 
-export async function createStudent(student: CreateStudentRequest): Promise<APIResult<Student>> {
+export async function createStudent(
+  student: CreateStudentRequest,
+  firebaseToken: string,
+): Promise<APIResult<Student>> {
   try {
-    const response = await POST("/student/create", student);
+    const headers = createAuthHeader(firebaseToken);
+    const response = await POST("/student/create", student, headers);
     const json = (await response.json()) as Student;
     console.log({ json });
     return { success: true, data: json };
@@ -28,9 +32,13 @@ export async function createStudent(student: CreateStudentRequest): Promise<APIR
   }
 }
 
-export async function editStudent(student: EditStudentRequest): Promise<APIResult<Student>> {
+export async function editStudent(
+  student: EditStudentRequest,
+  firebaseToken: string,
+): Promise<APIResult<Student>> {
   try {
-    const response = await PUT(`/student/edit/${student._id}`, student);
+    const headers = createAuthHeader(firebaseToken);
+    const response = await PUT(`/student/edit/${student._id}`, student, headers);
     const json = (await response.json()) as Student;
     return { success: true, data: json };
   } catch (error) {

frontend/src/components/AttendanceCard.tsx

@@ -17,9 +17,15 @@ export type CardProps = {
   program: Program;
   student: Student;
   setRemainingSessions: Dispatch<SetStateAction<number>>;
+  firebaseToken: string;
 };
 
-export function AttendanceCard({ program, student, setRemainingSessions }: CardProps) {
+export function AttendanceCard({
+  program,
+  student,
+  setRemainingSessions,
+  firebaseToken,
+}: CardProps) {
   const {
     register,
     setValue,
@@ -43,7 +49,7 @@ export function AttendanceCard({ program, student, setRemainingSessions }: CardP
       student: { studentId: student._id, attended: true, hoursAttended: data.hoursAttended },
     };
     console.log(newAbsenceSession);
-    createAbsenceSession(newAbsenceSession)
+    createAbsenceSession(newAbsenceSession, firebaseToken)
       .then((res) => {
         if (res.success) {
           console.log(res);

frontend/src/components/AttendanceTable.tsx

@@ -21,6 +21,7 @@ export type TableProps = {
   setRemainingSessions: Dispatch<SetStateAction<number>>;
   setAllAbsenceSessions: Dispatch<SetStateAction<AbsenceSessions>>;
   setRemainingAbsenceSessions: Dispatch<SetStateAction<number>>;
+  firebaseToken: string;
 };
 
 export function AttendanceTable({
@@ -30,6 +31,7 @@ export function AttendanceTable({
   setRemainingSessions,
   setAllAbsenceSessions,
   setRemainingAbsenceSessions,
+  firebaseToken,
 }: TableProps) {
   const {
     register,
@@ -77,7 +79,7 @@ export function AttendanceTable({
     });
     session.students = studentInfo;
     session.marked = true;
-    updateSession(session)
+    updateSession(session, firebaseToken)
       .then((newSession) => {
         if (newSession.success) {
           const absentStudents = newSession.data.students.filter((student) => !student.attended);

frontend/src/components/ProgramCard.tsx

@@ -1,11 +1,12 @@
 import { Poppins } from "next/font/google";
 import Image from "next/image";
 import { useRouter } from "next/navigation";
-import React, { useEffect, useState } from "react";
+import React, { useContext, useEffect, useState } from "react";
 
 import { Enrollment, Program, getProgramEnrollments } from "../api/programs";
 import ProgramFormButton from "../components/ProgramFormButton";
 import { ProgramProfile } from "../components/ProgramProfile";
+import { UserContext } from "../contexts/user";
 import { useWindowSize } from "../hooks/useWindowSize";
 import { cn } from "../lib/utils";
 
@@ -55,6 +56,8 @@ export function ProgramCard({
   archiveView = false,
 }: CardProps) {
   const { isTablet } = useWindowSize();
+  const [firebaseToken, setFirebaseToken] = useState<string>();
+  const { firebaseUser } = useContext(UserContext);
 
   const cardId = "card" + program._id;
   const editId = "edit" + program._id;
@@ -65,20 +68,35 @@ export function ProgramCard({
   const [enrollments, setEnrollments] = useState<[Enrollment]>();
 
   useEffect(() => {
-    getProgramEnrollments(program._id).then(
-      (result) => {
-        if (result.success) {
-          setEnrollments(result.data);
-          console.log("enrollments found");
-        } else {
-          console.log("error finding enrollments");
-        }
-      },
-      (error) => {
-        console.log(error);
-      },
-    );
-  }, []);
+    if (firebaseUser) {
+      firebaseUser
+        .getIdToken()
+        .then((token) => {
+          setFirebaseToken(token);
+        })
+        .catch((err) => {
+          console.log(err);
+        });
+    }
+  }, [firebaseUser]);
+
+  useEffect(() => {
+    if (firebaseToken) {
+      getProgramEnrollments(program._id, firebaseToken).then(
+        (result) => {
+          if (result.success) {
+            setEnrollments(result.data);
+            console.log("enrollments found");
+          } else {
+            console.log("error finding enrollments");
+          }
+        },
+        (error) => {
+          console.log(error);
+        },
+      );
+    }
+  }, [firebaseToken]);
 
   const optionsButton = document.getElementById(optionsId);
   if (optionsButton !== null) {