Add /student endpoints

backend/functions/package.json

@@ -16,8 +16,9 @@
   },
   "main": "lib/index.js",
   "dependencies": {
+    "firebase": "^10.7.1",
     "firebase-admin": "^11.8.0",
-    "firebase-functions": "^4.3.1"
+    "firebase-functions": "^4.6.0"
   },
   "devDependencies": {
     "@typescript-eslint/eslint-plugin": "^5.12.0",

backend/functions/src/index.ts

@@ -2,16 +2,26 @@ import * as functions from 'firebase-functions';
 import admin from 'firebase-admin';
 import express from 'express';
 import cors from 'cors';
-import ServiceAccount from '../service-account.json';
+
+import students from './routes/students/index';
+import teams from "./routes/teams/index"
+
+//import bodyParser from 'body-parser';
+
+const serviceAccount: string = require('../service-account.json');
+// import ServiceAccount from '../service-account.json';
 
 // initialize firebase in order to access its services
-admin.initializeApp({ credential: admin.credential.cert(JSON.stringify(ServiceAccount)) });
+admin.initializeApp({ credential: admin.credential.cert(serviceAccount) });
 
 //initialize express server
 const app = express();
 app.use(express.json());
 app.use(cors());
 
+app.use("/students", students)
+app.use("/teams", teams)
+
 const db = admin.firestore();
 
 exports.api = functions.https.onRequest(app);

backend/functions/src/routes/students/index.ts

@@ -0,0 +1,164 @@
+import express, { Request, Response } from 'express';
+import { db } from '../../index';
+// import { CollectionReference, Query } from 'firebase-admin/firestore';
+import {student, isStudent} from "./types"
+import { Query } from 'firebase-admin/database';
+import { CollectionReference } from 'firebase-admin/firestore';
+
+const students = express.Router();
+
+// TODO: Convert to middleware
+function catchAll(
+  func: (req: Request, res: Response) => Promise<void>
+): (req: Request, res: Response) => Promise<void> {
+  return async (req: Request, res: Response) => {
+    try {
+      await func(req, res);
+    } catch (e: any) {
+      res.status(500).send(e.message);
+    }
+  };
+}
+
+/**
+ * Creates a new student in the `students` collection using x-www-form-urlencoded data.
+ *
+ * Upon success returns the document ID with HTTP 202
+ * Upon fail returns HTTP 400
+ */
+students.post('/:email', catchAll(async (req, res) => {
+  const email = req.params.email
+  let studentData = req.body;
+
+  // Validate form data
+  if (!isStudent(studentData) || email == "") {
+    res.status(400).send({
+      error:
+        'Malformed student registration request. Missing some required fields.',
+    });
+    return;
+  }
+
+  // Check email not in database already
+  try {
+    let docRef = await db.collection('students').doc(email).get();
+
+    if (docRef.exists) {
+      res.status(400).send({
+        error: `Student with email: ${email} already exists.`,
+      });
+      return;
+    }
+  } catch (e: any) {
+    res.status(500).send({ error: `Problem with email validation. ${e.message}` });
+  }
+
+  // Create student with email
+  try {
+    await db.collection('students').doc(email).set(studentData);
+  } catch (e: any) {
+    res.status(400).send({ error: `Could not create student. ${e.message}` });
+    return;
+  }
+
+  res.sendStatus(200);
+}));
+
+/**
+ * Updates a student with new parameters. Does not support updating arrays yet.
+ */
+students.put('/:email', catchAll(async (req, res) => {
+  let email = req.params.email;
+  let studentData = req.body;
+
+  // Check that email field exists on req.body
+  if (email == "") {
+    res.status(404).send({
+      error: 'Student email not specified.',
+    });
+    return;
+  }
+
+  // Update the database
+  try {
+    await db
+      .collection('students')
+      .doc(email)
+      // @ts-ignore
+      .update(studentData);
+  } catch (e: any) {
+    res.status(404).send({
+      error: `Student with email: ${email} could not be updated. ${e.message}`,
+    });
+    return;
+  }
+
+  res.sendStatus(200);
+}));
+
+/**
+ * Retrives all students.
+ */
+students.get('/', catchAll(async (req, res) => {
+  let collectionRef: CollectionReference | Query = db.collection('students');
+
+  // Evaluate filters placed on GET
+  let filters: student = req.query;
+  Object.entries(filters).forEach(([key, value]) => {
+    // @ts-ignore
+    collectionRef = collectionRef.where(key, "==", value);
+  });
+
+  let snapshotRef = await collectionRef.get();
+
+  let addedData: Map<string, student> = new Map();
+  snapshotRef.forEach((doc) => {
+    addedData.set(doc.id, doc.data() as student);
+  });
+
+  res.status(200).send(Object.fromEntries(addedData));
+}));
+
+/**
+ * Retrieves student with specificed `email` param.
+ * Eg. GET /students/[email protected]
+ */
+students.get('/:email', catchAll(async (req, res) => {
+  let email = req.params.email;
+
+  let collectionRef = db.collection('students');
+  let docRef = await collectionRef.doc(email).get();
+
+  if (docRef.exists) {
+    res.status(200).send({[email]: docRef.data()});
+  } else {
+    res
+      .status(404)
+      .send({ error: `Could not get data from email: ${email}` });
+  }
+}));
+
+/**
+ * Deletes student from the students collection.
+ */
+students.delete('/:email', catchAll(async (req, res) => {
+  let email = req.params.email;
+  let collectionRef = db.collection('students');
+
+  // Handle when email not specified
+  if (email == '') {
+    res.status(400).send({ error: 'Email must be specified.' });
+    return;
+  }
+
+  try {
+    await collectionRef.doc(email).delete();
+  } catch (e: any) {
+    res.status(404).send({ error: `Cannot find email: ${email}. ${e.message}` });
+    return;
+  }
+
+  res.status(200).send(`Successfully deleted: ${email}`);
+}));
+
+export default students;

backend/functions/src/routes/students/types.ts

@@ -0,0 +1,24 @@
+export interface student {
+  firstName?: string;
+  lastName?: string;
+  gradYear?: number;
+  netid?: string;
+  school?: string;
+  allergies?: string;
+}
+
+export type emailed_student = student & {email : string};
+
+export function isStudent(data: object): data is emailed_student {
+  return (
+    'firstName' in data &&
+    'lastName' in data &&
+    'gradYear' in data &&
+    'netid' in data &&
+    'school' in data
+  );
+}
+
+export function isStudentMutation(data: object): data is student {
+  return !('email' in data) && Object.keys(data).length != 0;
+}

backend/functions/src/routes/teams/index.ts

@@ -0,0 +1,107 @@
+import express, {Request, Response} from 'express';
+import {db} from "../../index"
+import {isTeam} from "./types"
+
+const teams = express.Router()
+
+function catchAll(
+  func: (req: Request, res: Response) => Promise<void>
+): (req: Request, res: Response) => Promise<void> {
+  return async (req: Request, res: Response) => {
+    try {
+      await func(req, res);
+    } catch (e: any) {
+      res.status(500).send(e.message);
+    }
+  };
+}
+
+/**
+ * Creates a new team
+ * 
+ * Requires name attribute
+ * Requires owner attribute
+ */
+teams.post("/", catchAll(async (req, res) => {
+  const data = req.body;
+
+  // Validate form data
+  if (!isTeam(data)) {
+    res.status(400).send({
+      error: "Requested team must have name and owner attribute"
+    }); return;
+  }
+
+  // Check that owner exists in the database
+  let userRef = await db.collection('students').doc(data.name).get();
+  if (!userRef.exists) {
+    res.status(400).send({
+      error: 'User attempting to create team does not exist'
+    });
+  }
+
+  // Check for team existence
+  let docRef = await db.collection('teams').doc(data.name).get();
+
+  if (docRef.exists) {
+    res.status(400).send({
+      error: `Team with name: ${data.name} already exists.`
+    });
+    return;
+  }
+
+  // Attempt to create team
+  try {
+    await db
+      .collection('teams')
+      .doc(data.name)
+      .set({ owner: data.owner, members: [data.owner] });
+  } catch (e: any) {
+    res.status(400).send({ error: `Could not create team. ${e.message}` });
+    return;
+  }
+
+  res.sendStatus(200);
+}))
+
+/**
+ * Adds a member to a team
+ */
+teams.put(
+  '/member',
+  catchAll(async (req, res) => {
+
+  })
+);
+
+/**
+ * Changes the owner of a team. Can only be fulfilled by a team owner. Need auth to do this.
+ */
+teams.put(
+  '/changeOwner',
+  catchAll(async (req, res) => {})
+);
+
+/**
+ * Gets a team's data based off of its team. Requires auth again.
+ */
+teams.get(
+  '/',
+  catchAll(async (req, res) => {})
+);
+
+/**
+ * Deletes a team. Requires auth
+ */
+teams.delete("/", catchAll(async (req, res) => {
+
+}))
+
+/**
+ * Deletes a member from a team. Requires auth.
+ */
+teams.delete("/member", catchAll(async (req, res) => {
+
+}))
+
+export default teams

backend/functions/src/routes/teams/types.ts

@@ -0,0 +1,18 @@
+export interface team {
+  name: string;
+  owner: string;
+}
+
+export interface teamData {
+  name: string;
+  owner: string;
+  members: string[];
+}
+
+export function isTeam(t: object): t is team {
+  return "name" in t && "owner" in t;
+}
+
+export function isTeamData(t: object): t is teamData {
+  return isTeam(t) && "members" in t;
+}

frontend/src/config.json

@@ -0,0 +1,8 @@
+{
+  "apiKey": "AIzaSyD7QWAyZcNKCyG5HXLrHa7Gd3gHvjmuD3k",
+  "authDomain": "brh-registration.firebaseapp.com",
+  "projectId": "brh-registration",
+  "storageBucket": "brh-registration.appspot.com",
+  "messagingSenderId": "546493816978",
+  "appId": "1:546493816978:web:5d9acfebf78a2ee27d464b"
+}