Merge pull request #34 from GTBitsOfGood/davidgu/ListItemsRequestQuery

Davidgu/list items request query

Author: kavinphan

src/app/api/items/[unallocatedItemId]/unallocatedItemRequests/route.test.ts

@@ -0,0 +1,102 @@
+import { testApiHandler } from "next-test-api-route-handler";
+import * as appHandler from "./route";
+import { expect, test } from "@jest/globals";
+import { validateSession, invalidateSession } from "@/test/util/authMockUtils";
+import { fillDbMockWithUnallocatedItemRequestsForItemIdFiltering } from "@/test/util/dbMockUtils";
+import { dbMock } from "@/test/dbMock";
+
+test("Should return 401 for no session", async () => {
+  await testApiHandler({
+    params: { unallocatedItemId: "1" },
+    appHandler,
+    async test({ fetch }) {
+      invalidateSession();
+
+      const res = await fetch({ method: "GET" });
+      expect(res.status).toBe(401);
+      const json = await res.json();
+      expect(json).toEqual({ message: "Session required" });
+    },
+  });
+});
+
+test("Should return 403 for being PARTNER", async () => {
+  await testApiHandler({
+    appHandler,
+    async test({ fetch }) {
+      validateSession("PARTNER");
+
+      const res = await fetch({ method: "GET" });
+      expect(res.status).toBe(403);
+      const json = await res.json();
+      expect(json).toEqual({ message: "Unauthorized" });
+    },
+  });
+});
+
+test("Should return 200 for being STAFF", async () => {
+  await testApiHandler({
+    params: { unallocatedItemId: "1" },
+    appHandler,
+    async test({ fetch }) {
+      validateSession("STAFF");
+
+      const res = await fetch({ method: "GET" });
+      expect(res.status).toBe(200);
+    },
+  });
+});
+
+test("Should return 200 for being ADMIN", async () => {
+  await testApiHandler({
+    params: { unallocatedItemId: "1" },
+    appHandler,
+    async test({ fetch }) {
+      validateSession("ADMIN");
+
+      const res = await fetch({ method: "GET" });
+      expect(res.status).toBe(200);
+    },
+  });
+});
+
+test("Should return 200 for being SUPER_ADMIN", async () => {
+  await testApiHandler({
+    params: { unallocatedItemId: "1" },
+    appHandler,
+    async test({ fetch }) {
+      validateSession("SUPER_ADMIN");
+
+      const res = await fetch({ method: "GET" });
+      expect(res.status).toBe(200);
+    },
+  });
+});
+
+test("For an authorized session, should give all unallocated item requests pointed to the specificed item", async () => {
+  await testApiHandler({
+    params: { unallocatedItemId: "1" },
+    appHandler,
+    async test({ fetch }) {
+      fillDbMockWithUnallocatedItemRequestsForItemIdFiltering(10);
+
+      const unallocatedItemRequests =
+        await dbMock.unallocatedItemRequest.findMany();
+
+      validateSession("STAFF");
+      const res = await fetch({ method: "GET" });
+      expect(res.status).toBe(200);
+      const json = await res.json();
+      expect(json).toEqual({ unallocatedItemRequests });
+      // expect(json).toEqual({
+      //   unallocatedItemRequests: unallocatedItemRequests.forEach((uir) => {
+      //     return {
+      //       id: uir.id,
+      //       quantity: uir.quantity,
+      //       comments: uir.comments,
+      //     };
+      //   }),
+      // });
+    },
+  });
+});

src/app/api/items/[unallocatedItemId]/unallocatedItemRequests/route.ts

@@ -0,0 +1,61 @@
+import { auth } from "@/auth";
+import { db } from "@/db";
+import {
+  argumentError,
+  authenticationError,
+  authorizationError,
+} from "@/util/responses";
+import { UserType } from "@prisma/client";
+import { NextResponse } from "next/server";
+
+interface UnallocatedItemRequestsResponse {
+  unallocatedItemRequests: {
+    id: number;
+    partnerId: number;
+    quantity: number;
+    comments: string;
+  }[];
+}
+
+/**
+ * Handles GET requests to retrieve unallocated item requests that relate to an item id.
+ * @param request - the incoming request (unused)
+ * @param params - the item id to retrieve unallocated item requests for
+ * @returns 401 if the session is invalid
+ * @returns 403 if the user type isn't staff, admin, or super admin
+ * @returns 400 if the item id is not an integer
+ * @returns 200 and a json response with the unallocated item requests
+ */
+export async function GET(
+  request: Request,
+  { params }: { params: Promise<{ unallocatedItemId: string }> }
+) {
+  // Validate session
+  const session = await auth();
+  if (!session?.user) return authenticationError("Session required");
+  if (
+    session.user.type !== UserType.STAFF &&
+    session.user.type !== UserType.ADMIN &&
+    session.user.type !== UserType.SUPER_ADMIN
+  )
+    return authorizationError("Unauthorized");
+
+  // Get item id from request parameters
+  const itemId = parseInt((await params).unallocatedItemId);
+  if (isNaN(itemId)) return argumentError("Item Id must be an integer");
+
+  // Get all unallocated item requests for the specified item
+  const unallocatedItemRequests = await db.unallocatedItemRequest.findMany({
+    where: { itemId },
+    select: {
+      id: true,
+      partnerId: true,
+      quantity: true,
+      comments: true,
+    },
+  });
+
+  return NextResponse.json({
+    unallocatedItemRequests,
+  } as UnallocatedItemRequestsResponse);
+}

src/test/util/dbMockUtils.ts

@@ -1,5 +1,5 @@
 import { dbMock } from "@/test/dbMock";
-import { UnclaimedItem } from "@prisma/client";
+import { UnallocatedItemRequest, UnclaimedItem } from "@prisma/client";
 
 // Helper util methods for testing
 
@@ -34,3 +34,26 @@ export async function fillDbMockWithManyUnclaimedItems(
   dbMock.unclaimedItem.findMany.mockResolvedValue(items);
   return items;
 }
+
+export async function fillDbMockWithUnallocatedItemRequestsForItemIdFiltering(
+  num: number
+) {
+  // const numberOfItems = 10;
+  const numberOfPartners = 10;
+
+  const unallocatedItemRequests: UnallocatedItemRequest[] = [];
+
+  for (let i = 0; i < num; i++) {
+    unallocatedItemRequests.push({
+      id: i,
+      quantity: Math.floor(Math.random() * 1000),
+      partnerId: Math.floor(Math.random() * numberOfPartners),
+      itemId: 1,
+      comments: "Test unallocated item request " + i,
+    });
+  }
+
+  dbMock.unallocatedItemRequest.findMany.mockResolvedValue(
+    unallocatedItemRequests
+  );
+}