Rewrite phase 1.

Started improved client code structure.

Implemented session based authentication serverside.

Implemented user, match, and sport database models serverside.

Implemented Controllers for variety of C and R operations of CRUD.

sports-matcher/server/controllers/matchController.js

@@ -0,0 +1,94 @@
+import express from "express";
+import { authenticationGuard } from "../middleware/authority.js";
+import { needDatabase } from "../middleware/database.js";
+import matchModel from "../schemas/matchModel.js";
+import sportModel from "../schemas/sportModel.js";
+import userModel from "../schemas/userModel.js";
+const MatchController = express.Router();
+
+MatchController.get("/search/:sport", needDatabase, async (req, res) => {
+    try {
+        let sport = sportModel.findByName(req.params.sport);
+        let query = matchModel.find({ sport: sport._id });
+        query.where("when").gte(Date.now); // We don't want to return any results of matches that have already occurred.
+        if (req.session.userId) query.where("publicity").gte(1).where("friends").in(req.session.userId);
+        if (req.query.within) query.where("location").within({ center: req.query.location.split(","), radius: req.query.within });
+        if (req.query.minDifficulty) query.where("difficulty").gte(req.query.minDifficulty);
+        if (req.query.maxDifficulty) query.where("difficulty").lte(req.query.maxDifficulty);
+        if (req.query.beforeDate) query.where("when").lte(req.query.beforeDate);
+
+        let queryResults = await query;
+        res.send({ queryResults });
+    } catch (error) {
+        console.error(error);
+        res.status(500).send("Internal server error.");
+    }
+});
+
+MatchController.get("/recent/:limit?", needDatabase, async (req, res) => {
+    let limit = req.params.limit;
+    if (!req.params.limit) limit = 10;
+    if (isNaN(limit)) {
+        res.status(400).send("Limit parameter not a number.");
+        return;
+    }
+    if (limit > 50) {
+        res.status(400).send("Limit greater than maximum limit of 50.");
+        return;
+    }
+    try {
+        const recent = await matchModel.find().where("publicity").gte(2).limit(limit).sort({ createDate: -1 });
+        res.status(200).send({ recent: recent });
+    } catch (err) {
+        console.error(err);
+        res.status(500).send("Internal server error.");
+        // TODO: Check and improve error handling.
+    }
+});
+
+// TODO: delete, update match.
+MatchController.post("/", needDatabase, authenticationGuard, async (req, res) => {
+    try {
+        const userId = req.session.userId;
+        const user = await userModel.findById(userId);
+        const match = new matchModel({
+            title: req.body.title,
+            when: req.body.when,
+            public: req.body.public,
+            location: req.body.location,
+            creator: userId,
+            difficulty: req.body.difficulty,
+            sport: await sportModel.findByName(req.body.sport),
+            participants: [user._id]
+        });
+        await match.save();
+        user.createdMatches.push(match._id);
+        user.participatingMatches.push(match._id);
+        await user.save();
+        res.status(201).send(match);
+    } catch (error) {
+        console.error(error);
+        res.status(500).send("Internal server error.");
+        // TODO: Develop the error handling.
+    }
+});
+
+MatchController.get("/:matchId", needDatabase, async (req, res) => {
+    if (!req.params.matchId) {
+        res.status(404).send("Id must be provided to retrieve match");
+        return;
+    }
+    try {
+        const match = await matchModel.findById(req.params.matchId);
+        if (match) {
+            res.status(200).send(match);
+        } else {
+            res.status(404).send("Could not find match with ID: " + req.params.matchId);
+        }
+    } catch (error) {
+        res.status(500).send("Internal server error.");
+        // TODO: Develop the error handling.
+    }
+});
+
+export default MatchController;

sports-matcher/server/controllers/sportController.js

@@ -0,0 +1,48 @@
+import express from "express";
+import { authenticationGuard } from "../middleware/authority.js";
+import { needDatabase } from "../middleware/database.js";
+import sportModel from "../schemas/sportModel.js";
+import userModel from "../schemas/userModel.js";
+
+const SportController = express.Router();
+
+SportController.post("/", needDatabase, authenticationGuard, async (req, res) => {
+    const user = await userModel.findById(req.session.userId);
+    try {
+        if (user.accessLevel <= 2) {
+            res.status(403).send("Insufficient privileges.");
+            return;
+        }
+        const sport = new sportModel({
+            name: req.body.name,
+            maxPlayers: req.body.maxPlayers,
+            minPlayers: req.body.minPlayers,
+            description: req.body.description
+        });
+        await sport.save();
+        res.status(201).send("Successfully created new sport.");
+    } catch (error) {
+        res.status(500).send("Internal server error.");
+        // TODO: Add proper error checking here.
+    }
+});
+
+SportController.get("/:sportId", needDatabase, async (req, res) => {
+    try {
+        res.status(200).send(await sportModel.findById(req.params.sportId));
+    } catch (error) {
+        res.status(500).send("Internal server error.");
+        // TODO: Add proper error checking here.
+    }
+});
+
+SportController.get("/", needDatabase, async (req, res) => {
+    try {
+        res.status(200).send(await sportModel.find());
+    } catch (error) {
+        res.status(500).send("Internal server error.");
+        // TODO: Add proper error checking here.
+    }
+});
+
+export default SportController;

sports-matcher/server/controllers/userController.js

@@ -0,0 +1,169 @@
+import express from "express";
+import { authenticationGuard } from "../middleware/authority.js";
+import { needDatabase } from "../middleware/database.js";
+import User from "../schemas/userModel.js";
+const UserController = express.Router();
+
+UserController.post("/login", needDatabase, async (req, res) => {
+    try {
+        const email = req.body.email;
+        const pwd = req.body.password;
+        const user = await User.credentialsExist(email, pwd);
+        if (!user) {
+            res.sendStatus(401);
+            return;
+        } else {
+            req.session.userId = user._id;
+            req.session.email = user.email;
+            res.status(200).send("Authenticated.");
+        }
+    } catch (error) {
+        if (error.name === "TypeError") {
+            res.status(400).send("Missing required user info.");
+        } else if (error.message === "Credentials do not exist.") {
+            res.status(401).send("Credentials do not exist.");
+        } else {
+            console.error(error);
+            if (process.env.NODE_ENV === "development") {
+                res.status(500).send(error.toString());
+            } else {
+                res.status(500).send("Internal server error. This issue has been noted.");
+            }
+        }
+    }
+});
+
+UserController.get("/logout", authenticationGuard, (req, res) => {
+    req.session.destroy((err) => {
+        if (err) {
+            console.error(err);
+            if (process.env.NODE_ENV === "development") {
+                res.status(500).send(err.toString());
+            } else {
+                res.status(500).send("Internal server error. This issue has been noted.");
+            }
+            res.status(500).send("");
+        } else {
+            res.sendStatus(200);
+        }
+    });
+});
+
+UserController.get("/email/:userId?", needDatabase, authenticationGuard, async (req, res) => {
+    if (!req.params.userId) req.params.userId = req.session.userId;
+    const curUser = await User.findById(req.session.userId);
+    const selUser = req.session.userId === req.params.userId ? curUser : await User.findById(req.params.userId);
+    if (selUser.email.public || curUser._id === selUser._id || curUser.accessLevel > 2) {
+        res.status(200).send({ email: selUser.email });
+    } else {
+        res.status(401).send("Could not authenticate request.");
+    }
+});
+
+UserController.get("/firstName/:userId?", needDatabase, authenticationGuard, async (req, res) => {
+    if (!req.params.userId) req.params.userId = req.session.userId;
+    const curUser = await User.findById(req.session.userId);
+    const selUser = req.session.userId === req.params.userId ? curUser : await User.findById(req.params.userId);
+    if (selUser.firstName.public || curUser._id === selUser._id || curUser.accessLevel > 2) {
+        res.status(200).send({ firstName: selUser.firstName });
+    } else {
+        res.status(401).send("Could not authenticate request.");
+    }
+});
+
+UserController.get("/lastName/:userId?", needDatabase, authenticationGuard, async (req, res) => {
+    if (!req.params.userId) req.params.userId = req.session.userId;
+    const curUser = await User.findById(req.session.userId);
+    const selUser = req.session.userId === req.params.userId ? curUser : await User.findById(req.params.userId);
+    if (selUser.lastName.public || curUser._id === selUser._id || curUser.accessLevel > 2) {
+        res.status(200).send({ email: selUser.lastName });
+    } else {
+        res.status(401).send("Could not authenticate request.");
+    }
+});
+
+UserController.get("/phone/:userId?", needDatabase, authenticationGuard, async (req, res) => {
+    if (!req.params.userId) req.params.userId = req.session.userId;
+    const curUser = await User.findById(req.session.userId);
+    const selUser = req.session.userId === req.params.userId ? curUser : await User.findById(req.params.userId);
+    if (selUser.phone.public || curUser._id === selUser._id || curUser.accessLevel > 2) {
+        res.status(200).send({ phone: selUser.phone });
+    } else {
+        res.status(401).send("Could not authenticate request.");
+    }
+});
+
+UserController.get("/participatingMatches/:userId?", needDatabase, authenticationGuard, async (req, res) => {
+    if (!req.params.userId) req.params.userId = req.session.userId;
+    const curUser = await User.findById(req.session.userId);
+    const selUser = req.session.userId === req.params.userId ? curUser : await User.findById(req.params.userId);
+    if (selUser.participatingMatches.public || curUser._id === selUser._id || curUser.accessLevel > 2) {
+        res.status(200).send({ participatingMatches: selUser.participatingMatches });
+    } else {
+        res.status(401).send("Could not authenticate request.");
+    }
+});
+
+UserController.get("/joinDate/:userId?", needDatabase, authenticationGuard, async (req, res) => {
+    if (!req.params.userId) req.params.userId = req.session.userId;
+    const curUser = await User.findById(req.session.userId);
+    const selUser = req.session.userId === req.params.userId ? curUser : await User.findById(req.params.userId);
+    if (curUser._id === selUser._id || curUser.accessLevel > 2) {
+        res.status(200).send({ joinDate: selUser.joinDate });
+    } else {
+        res.status(401).send("Could not authenticate request.");
+    }
+});
+
+UserController.get("/createdMatches/:userId?", needDatabase, authenticationGuard, async (req, res) => {
+    if (!req.params.userId) req.params.userId = req.session.userId;
+    const curUser = await User.findById(req.session.userId);
+    const selUser = req.session.userId === req.params.userId ? curUser : await User.findById(req.params.userId);
+    if (curUser._id === selUser._id || curUser.accessLevel > 2) {
+        res.status(200).send({ createdMatches: selUser.createdMatches });
+    } else {
+        res.status(401).send("Could not authenticate request.");
+    }
+});
+
+// TODO: Finish update requests using put.
+
+UserController.post("/", needDatabase, async (req, res) => {
+    try {
+        let createdUser = new User({
+            email: req.body.email,
+            firstName: req.body.firstName,
+            lastName: req.body.lastName,
+            phone: req.body.phone,
+            password: req.body.password,
+        });
+        await createdUser.save();
+        res.sendStatus(201);
+        return;
+    } catch (err) {
+        if (err.name === "TypeError" || err.name === "ValidationError") {
+            if (process.env.NODE_ENV === "development") {
+                console.error(err);
+                res.status(400).send(err.toString());
+            } else {
+                res.status(400).send("Missing required user info.");
+            }
+        } else if (err.name === "MongoServerError" && err.message.startsWith("E11000")) {
+            if (process.env.NODE_ENV === "development") {
+                console.error(err);
+                res.status(409).send(err.toString());
+            } else {
+                res.status(409).send("User already exists.");
+            }
+        } else {
+            console.error(err);
+            if (process.env.NODE_ENV === "development") {
+                res.status(500).send(err.toString());
+            } else {
+                res.status(500).send("Internal server error. This issue has been noted.");
+            }
+        }
+    }
+});
+
+export default UserController;