basics

Author: devksingh4

src/api/routes/roomRequests.ts

@@ -1,6 +1,7 @@
 import { FastifyPluginAsync } from "fastify";
 import rateLimiter from "api/plugins/rateLimiter.js";
 import {
+  roomGetResponse,
   roomRequestBaseSchema,
   RoomRequestFormValues,
   roomRequestPostResponse,
@@ -17,7 +18,11 @@ import {
   DatabaseInsertError,
   InternalServerError,
 } from "common/errors/index.js";
-import { PutItemCommand, QueryCommand } from "@aws-sdk/client-dynamodb";
+import {
+  PutItemCommand,
+  QueryCommand,
+  TransactWriteItemsCommand,
+} from "@aws-sdk/client-dynamodb";
 import { genericConfig } from "common/config.js";
 import { marshall, unmarshall } from "@aws-sdk/util-dynamodb";
 import { z } from "zod";
@@ -81,11 +86,7 @@ const roomRequestRoutes: FastifyPluginAsync = async (fastify, _options) => {
     {
       schema: {
         response: {
-          200: zodToJsonSchema(
-            z.array(
-              roomRequestBaseSchema.extend({ requestId: z.string().uuid() }),
-            ),
-          ),
+          200: zodToJsonSchema(roomGetResponse),
         },
       },
       onRequest: async (request, reply) => {
@@ -116,7 +117,7 @@ const roomRequestRoutes: FastifyPluginAsync = async (fastify, _options) => {
           ExpressionAttributeNames: {
             "#hashKey": "userId#requestId",
           },
-          ProjectionExpression: "requestId, host, title",
+          ProjectionExpression: "requestId, host, title, semester",
           ExpressionAttributeValues: {
             ":semesterValue": { S: semesterId },
             ":username": { S: request.username },
@@ -129,8 +130,49 @@ const roomRequestRoutes: FastifyPluginAsync = async (fastify, _options) => {
           message: "Could not get room requests.",
         });
       }
-      const items = response.Items.map((x) => unmarshall(x));
-      return reply.status(200).send(items);
+      const items = response.Items.map((x) => {
+        const item = unmarshall(x) as {
+          host: string;
+          title: string;
+          requestId: string;
+          status: string;
+        };
+        const statusPromise = fastify.dynamoClient.send(
+          new QueryCommand({
+            TableName: genericConfig.RoomRequestsStatusTableName,
+            KeyConditionExpression: "requestId = :requestId",
+            ExpressionAttributeValues: {
+              ":requestId": { S: item.requestId },
+            },
+            ProjectionExpression: "#status",
+            ExpressionAttributeNames: {
+              "#status": "status",
+            },
+            ScanIndexForward: false,
+            Limit: 1,
+          }),
+        );
+
+        return statusPromise.then((statusResponse) => {
+          if (
+            !statusResponse ||
+            !statusResponse.Items ||
+            statusResponse.Items.length == 0
+          ) {
+            return "unknown";
+          }
+          const statuses = statusResponse.Items.map((s) => unmarshall(s));
+          const latestStatus = statuses.length > 0 ? statuses[0].status : null;
+          return {
+            ...item,
+            status: latestStatus,
+          };
+        });
+      });
+
+      const itemsWithStatus = await Promise.all(items);
+
+      return reply.status(200).send(itemsWithStatus);
     },
   );
   fastify.post<{ Body: RoomRequestFormValues }>(
@@ -161,12 +203,31 @@ const roomRequestRoutes: FastifyPluginAsync = async (fastify, _options) => {
         semesterId: request.body.semester,
       };
       try {
-        await fastify.dynamoClient.send(
-          new PutItemCommand({
-            TableName: genericConfig.RoomRequestsTableName,
-            Item: marshall(body),
-          }),
-        );
+        const createdAt = new Date().toISOString();
+        const transactionCommand = new TransactWriteItemsCommand({
+          TransactItems: [
+            {
+              Put: {
+                TableName: genericConfig.RoomRequestsTableName,
+                Item: marshall(body),
+              },
+            },
+            {
+              Put: {
+                TableName: genericConfig.RoomRequestsStatusTableName,
+                Item: marshall({
+                  requestId,
+                  semesterId: request.body.semester,
+                  "createdAt#status": `${createdAt}#${RoomRequestStatus.CREATED}`,
+                  createdBy: request.username,
+                  status: RoomRequestStatus.CREATED,
+                  notes: "This request was created by the user.",
+                }),
+              },
+            },
+          ],
+        });
+        await fastify.dynamoClient.send(transactionCommand);
       } catch (e) {
         if (e instanceof BaseError) {
           throw e;
@@ -182,6 +243,100 @@ const roomRequestRoutes: FastifyPluginAsync = async (fastify, _options) => {
       });
     },
   );
+  fastify.get<{
+    Body: undefined;
+    Params: { requestId: string; semesterId: string };
+  }>(
+    "/:semesterId/:requestId",
+    {
+      onRequest: async (request, reply) => {
+        await fastify.authorize(request, reply, [AppRoles.ROOM_REQUEST_CREATE]);
+      },
+    },
+    async (request, reply) => {
+      const requestId = request.params.requestId;
+      const semesterId = request.params.semesterId;
+      let command;
+      if (request.userRoles?.has(AppRoles.BYPASS_OBJECT_LEVEL_AUTH)) {
+        command = new QueryCommand({
+          TableName: genericConfig.RoomRequestsTableName,
+          IndexName: "RequestIdIndex",
+          KeyConditionExpression: "requestId = :requestId",
+          FilterExpression: "semesterId = :semesterId",
+          ExpressionAttributeValues: {
+            ":requestId": { S: requestId },
+            ":semesterId": { S: semesterId },
+          },
+          Limit: 1,
+        });
+      } else {
+        command = new QueryCommand({
+          TableName: genericConfig.RoomRequestsTableName,
+          KeyConditionExpression:
+            "semesterId = :semesterId AND #userIdRequestId = :userRequestId",
+          ExpressionAttributeValues: {
+            ":userRequestId": { S: `${request.username}#${requestId}` },
+            ":semesterId": { S: semesterId },
+          },
+          ExpressionAttributeNames: {
+            "#userIdRequestId": "userId#requestId",
+          },
+          Limit: 1,
+        });
+      }
+      try {
+        const resp = await fastify.dynamoClient.send(command);
+        if (!resp.Items || resp.Count != 1) {
+          throw new DatabaseFetchError({
+            message: "Recieved no response.",
+          });
+        }
+        // this isn't atomic, but that's fine - a little inconsistency on this isn't a problem.
+        try {
+          const statusesResponse = await fastify.dynamoClient.send(
+            new QueryCommand({
+              TableName: genericConfig.RoomRequestsStatusTableName,
+              KeyConditionExpression: "requestId = :requestId",
+              ExpressionAttributeValues: {
+                ":requestId": { S: requestId },
+              },
+              ProjectionExpression: "#createdAt,#notes,#createdBy",
+              ExpressionAttributeNames: {
+                "#createdBy": "createdBy",
+                "#createdAt": "createdAt#status",
+                "#notes": "notes",
+              },
+            }),
+          );
+          const updates = statusesResponse.Items?.map((x) => {
+            const unmarshalled = unmarshall(x);
+            return {
+              createdBy: unmarshalled["createdBy"],
+              createdAt: unmarshalled["createdAt#status"].split("#")[0],
+              status: unmarshalled["createdAt#status"].split("#")[1],
+              notes: unmarshalled["notes"],
+            };
+          });
+          return reply
+            .status(200)
+            .send({ data: unmarshall(resp.Items[0]), updates });
+        } catch (e) {
+          request.log.error(e);
+          throw new DatabaseFetchError({
+            message: "Could not get request status.",
+          });
+        }
+      } catch (e) {
+        request.log.error(e);
+        if (e instanceof BaseError) {
+          throw e;
+        }
+        throw new DatabaseInsertError({
+          message: "Could not find by ID.",
+        });
+      }
+    },
+  );
 };
 
 export default roomRequestRoutes;

src/common/types/roomRequest.ts

@@ -71,11 +71,9 @@ export const roomRequestStatusUpdate = roomRequestStatusUpdateRequest.extend({
 export const roomRequestBaseSchema = z.object({
   host: z.enum(OrganizationList),
   title: z.string().min(2, "Title must have at least 2 characters"),
+  semester: z.string().regex(/^(fa|sp|su|wi)\d{2}$/, "Invalid semester provided"),
 })
 export const roomRequestSchema = roomRequestBaseSchema.extend({
-  host: z.enum(OrganizationList),
-  semester: z.string().regex(/^(fa|sp|su|wi)\d{2}$/, "Invalid semester provided"),
-  title: z.string().min(2, "Title must have at least 2 characters"),
   theme: z.enum(eventThemeOptions),
   description: z.string()
     .min(10, "Description must have at least 10 words")
@@ -108,7 +106,7 @@ export const roomRequestPostResponse = z.object({
 
 export const roomRequestGetResponse = z.object({
   data: roomRequestSchema,
-  statusUpdates: z.array(roomRequestStatusUpdate),
+  updates: z.array(roomRequestStatusUpdate),
 })
 
 export type RoomRequestPostResponse = z.infer<typeof roomRequestPostResponse>;
@@ -118,3 +116,9 @@ export type RoomRequestStatusUpdate = z.infer<typeof roomRequestStatusUpdate>;
 export type RoomRequestGetResponse = z.infer<typeof roomRequestGetResponse>;
 
 export type RoomRequestStatusUpdatePostBody = z.infer<typeof roomRequestStatusUpdateRequest>;
+
+export const roomGetResponse = z.array(
+  roomRequestBaseSchema.extend({ requestId: z.string().uuid(), status: z.nativeEnum(RoomRequestStatus) }),
+);
+
+export type RoomRequestGetAllResponse = z.infer<typeof roomGetResponse>;

src/ui/Router.tsx

@@ -20,6 +20,7 @@ import { ManageIamPage } from './pages/iam/ManageIam.page';
 import { ManageProfilePage } from './pages/profile/ManageProfile.page';
 import { ManageStripeLinksPage } from './pages/stripe/ViewLinks.page';
 import { ManageRoomRequestsPage } from './pages/roomRequest/RoomRequestLanding.page';
+import { ViewRoomRequest } from './pages/roomRequest/ViewRoomRequest.page';
 
 const ProfileRediect: React.FC = () => {
   const location = useLocation();
@@ -167,6 +168,10 @@ const authenticatedRouter = createBrowserRouter([
     path: '/roomRequests',
     element: <ManageRoomRequestsPage />,
   },
+  {
+    path: '/roomRequests/:semesterId/:requestId',
+    element: <ViewRoomRequest />,
+  },
   // Catch-all route for authenticated users shows 404 page
   {
     path: '*',

src/ui/pages/roomRequest/ExistingRoomRequests.tsx

@@ -1,5 +1,57 @@
-const ExistingRoomRequests: React.FC = () => {
-  return null;
+import React, { useEffect, useState } from 'react';
+import { RoomRequestGetAllResponse } from '@common/types/roomRequest';
+import { Anchor, Loader, Table } from '@mantine/core';
+import { useNavigate } from 'react-router-dom';
+import { formatStatus } from './roomRequestUtils';
+
+interface ExistingRoomRequestsProps {
+  getRoomRequests: (semester: string) => Promise<RoomRequestGetAllResponse>;
+  semester: string;
+}
+const ExistingRoomRequests: React.FC<ExistingRoomRequestsProps> = ({
+  getRoomRequests,
+  semester,
+}) => {
+  const [data, setData] = useState<RoomRequestGetAllResponse | null>(null);
+  const navigate = useNavigate();
+  useEffect(() => {
+    const inner = async () => {
+      setData(await getRoomRequests(semester));
+    };
+    inner();
+  }, [semester]);
+  return (
+    <>
+      <Table>
+        <Table.Thead>
+          <Table.Tr>
+            <Table.Th>Name</Table.Th>
+            <Table.Th>Host</Table.Th>
+            <Table.Th>Status</Table.Th>
+          </Table.Tr>
+        </Table.Thead>
+        {!data && <Loader size={32} />}
+        {data && (
+          <Table.Tbody>
+            {data.map((item) => {
+              return (
+                <Table.Tr key={item.requestId}>
+                  <Table.Td
+                    onClick={() => navigate(`/roomRequests/${item.semester}/${item.requestId}`)}
+                    style={{ cursor: 'pointer', color: 'var(--mantine-color-blue-6)' }}
+                  >
+                    {item.title}
+                  </Table.Td>
+                  <Table.Td>{item.host}</Table.Td>
+                  <Table.Td>{formatStatus(item.status)}</Table.Td>
+                </Table.Tr>
+              );
+            })}
+          </Table.Tbody>
+        )}
+      </Table>
+    </>
+  );
 };
 
 export default ExistingRoomRequests;

src/ui/pages/roomRequest/NewRoomRequest.tsx

@@ -129,7 +129,7 @@ const YesNoField: React.FC<YesNoFieldProps> = ({
 };
 
 interface NewRoomRequestProps {
-  createRoomRequest: (payload: RoomRequestFormValues) => Promise<RoomRequestPostResponse>;
+  createRoomRequest?: (payload: RoomRequestFormValues) => Promise<RoomRequestPostResponse>;
   initialValues?: RoomRequestFormValues;
   disabled?: boolean;
 }
@@ -147,7 +147,7 @@ const NewRoomRequest: React.FC<NewRoomRequestProps> = ({
   const semesterValues = semesterOptions.map((x) => x.value);
 
   const form = useForm<RoomRequestFormValues>({
-    enhanceGetInputProps: () => ({ disabled }),
+    enhanceGetInputProps: () => ({ readOnly: disabled }),
     initialValues: initialValues || {
       host: '',
       title: '',
@@ -290,6 +290,9 @@ const NewRoomRequest: React.FC<NewRoomRequestProps> = ({
       }
     });
     try {
+      if (!createRoomRequest) {
+        return;
+      }
       setIsSubmitting(true);
       const response = await createRoomRequest(apiFormValues);
       notifications.show({
@@ -575,9 +578,10 @@ const NewRoomRequest: React.FC<NewRoomRequestProps> = ({
             Back
           </Button>
         )}
-        {active !== numSteps && (
-          <Button onClick={nextStep}>{active === numSteps - 1 ? 'Review' : 'Next'}</Button>
-        )}
+        {active !== numSteps &&
+          (disabled && active === numSteps - 1 ? null : (
+            <Button onClick={nextStep}>{active === numSteps - 1 ? 'Review' : 'Next'}</Button>
+          ))}
         {active === numSteps && !disabled && (
           <Button onClick={handleSubmit} color="green">
             {isSubmitting ? (