fully implements activities backend

Author: jackgarritano

src/controllers/activities.controller.ts

@@ -11,9 +11,9 @@ export const createActivity = async (activitiesFields: ActivitiesType) => {
       throw new HttpError(HttpStatus.BAD_REQUEST, "Duplicate item name");
     }
 
-    const newActivities = new ActivitiesModel(activitiesFields);
-    await newActivities.save();
-    return newActivities;
+    const newActivity = new ActivitiesModel(activitiesFields);
+    await newActivity.save();
+    return newActivity;
   } catch (err: unknown) {
     if (err instanceof HttpError) {
       throw err;
@@ -74,19 +74,19 @@ export const getActivityById = async (user: string, activityId: string) => {
 
 export const updateActivity = async (
   user: string,
+	activityId: string,
   activitiesFields: ActivitiesType,
 ) => {
   try {
-    const _id = activitiesFields._id; // Extract the _id from activitiesFields
-    if (!_id) {
+    if (!activityId) {
       throw new HttpError(
         HttpStatus.BAD_REQUEST,
         "Missing activity ID for update",
       );
     }
 
     const updatedActivity = await ActivitiesModel.findOneAndUpdate(
-      { _id: _id, user: user }, // Query to match the document by _id and user
+      { _id: activityId, user: user }, // Query to match the document by _id and user
       { $set: activitiesFields }, // Update operation
       { new: true, runValidators: true }, // Options: return the updated document and run schema validators
     );

src/index.ts

@@ -25,7 +25,7 @@ app.use(helmet());
  * Uses the verifyToken middleware to protect the "/data" route
  * Use the verifyToken to protect all the routes that require authentication
  */
-app.use("/api", /*verifyToken,*/ router);
+app.use("/api", verifyToken, router);
 app.use("/example", verifyToken, exampleRoute);
 
 // Default route: Unprotected

src/routers/activities.router.ts

@@ -1,5 +1,11 @@
 import { Router, type Request, type Response } from "express";
-import { createActivity } from "../controllers/activities.controller";
+import {
+  createActivity,
+  getAllActivities,
+  getActivityById,
+  updateActivity,
+  deleteActivity,
+} from "../controllers/activities.controller";
 import { HttpError, HttpStatus } from "../utils/errors";
 import { type ActivitiesType } from "../models/activities.model";
 
@@ -10,7 +16,25 @@ activitiesRouter.post(
   "/",
   async (req: Request<any, any, ActivitiesType>, res: Response) => {
     try {
-      const activities = await createActivity(req.body);
+      const activity = await createActivity(req.body);
+      res.status(HttpStatus.OK).json(activity);
+    } catch (err: unknown) {
+      if (err instanceof HttpError) {
+        res.status(err.errorCode).json({ error: err.message });
+      } else {
+        res
+          .status(HttpStatus.INTERNAL_SERVER_ERROR)
+          .json({ error: "An unknown error occurred" });
+      }
+    }
+  },
+);
+
+activitiesRouter.get(
+  "/",
+  async (req: Request<any, any, ActivitiesType>, res: Response) => {
+    try {
+      const activities = await getAllActivities(req.body.user);
       res.status(HttpStatus.OK).json(activities);
     } catch (err: unknown) {
       if (err instanceof HttpError) {
@@ -23,3 +47,57 @@ activitiesRouter.post(
     }
   },
 );
+
+activitiesRouter.get(
+  "/:activityId",
+  async (req: Request<any, any, ActivitiesType>, res: Response) => {
+    try {
+      const activity = await getActivityById(req.body.user, req.params.activityId);
+      res.status(HttpStatus.OK).json(activity);
+    } catch (err: unknown) {
+      if (err instanceof HttpError) {
+        res.status(err.errorCode).json({ error: err.message });
+      } else {
+        res
+          .status(HttpStatus.INTERNAL_SERVER_ERROR)
+          .json({ error: "An unknown error occurred" });
+      }
+    }
+  },
+);
+
+activitiesRouter.put(
+  "/:activityId",
+  async (req: Request<any, any, ActivitiesType>, res: Response) => {
+    try {
+      const activity = await updateActivity(req.body.user, req.params.activityId, req.body);
+      res.status(HttpStatus.OK).json(activity);
+    } catch (err: unknown) {
+      if (err instanceof HttpError) {
+        res.status(err.errorCode).json({ error: err.message });
+      } else {
+        res
+          .status(HttpStatus.INTERNAL_SERVER_ERROR)
+          .json({ error: "An unknown error occurred" });
+      }
+    }
+  },
+);
+
+activitiesRouter.delete(
+  "/:activityId",
+  async (req: Request<any, any, ActivitiesType>, res: Response) => {
+    try {
+      const activity = await deleteActivity(req.body.user, req.params.activityId);
+      res.status(HttpStatus.OK).json(activity);
+    } catch (err: unknown) {
+      if (err instanceof HttpError) {
+        res.status(err.errorCode).json({ error: err.message });
+      } else {
+        res
+          .status(HttpStatus.INTERNAL_SERVER_ERROR)
+          .json({ error: "An unknown error occurred" });
+      }
+    }
+  },
+);

src/tests/controllers.tests/activities.test.ts

@@ -49,9 +49,8 @@ describe("Activities controller tests", () => {
 
     expect(returnedActivity).toMatchObject(activityDummyData1);
 
-    await updateActivity(activityDummyData1.user, {
+    await updateActivity(activityDummyData1.user, returnedActivities[0]._id, {
       ...activityDummyData1,
-      _id: returnedActivities[0]._id,
       itemName: "activitiesItem2",
     } as ActivitiesType);
     const returnedActivity2 = await getActivityById(
@@ -61,9 +60,11 @@ describe("Activities controller tests", () => {
     expect(returnedActivity2?.itemName).to.equal("activitiesItem2");
 
     await deleteActivity(activityDummyData1.user, returnedActivities[0]._id);
-		const returnedActivities3 = await getAllActivities(activityDummyData1.user);
-		expect(returnedActivities3.length).to.equal(0);
+    const returnedActivities3 = await getAllActivities(activityDummyData1.user);
+    expect(returnedActivities3.length).to.equal(0);
 
-		await expect(updateActivity(activityDummyData1.user, {} as ActivitiesType)).rejects.toThrowError("Missing");
+    await expect(
+      updateActivity(activityDummyData1.user, "", {} as ActivitiesType),
+    ).rejects.toThrowError("Missing");
   });
 });