Merge branch 'develop' into #2028-delete-design-review-hook

Author: bderbs30

src/backend/src/controllers/design-reviews.controllers.ts

@@ -13,6 +13,15 @@ export default class DesignReviewsController {
     }
   }
 
+  static async getAllTeamTypes(req: Request, res: Response, next: NextFunction) {
+    try {
+      const teamTypes = await DesignReviewsService.getAllTeamTypes();
+      return res.status(200).json(teamTypes);
+    } catch (error: unknown) {
+      next(error);
+    }
+  }
+
   static async deleteDesignReview(req: Request, res: Response, next: NextFunction) {
     try {
       const drId: string = req.params.designReviewId;
@@ -27,33 +36,16 @@ export default class DesignReviewsController {
   static async createDesignReview(req: Request, res: Response, next: NextFunction) {
     try {
       const submitter: User = await getCurrentUser(res);
-      const {
-        dateScheduled,
-        teamTypeId,
-        requiredMemberIds,
-        optionalMemberIds,
-        location,
-        isOnline,
-        isInPerson,
-        zoomLink,
-        docTemplateLink,
-        wbsNum,
-        meetingTimes
-      } = req.body;
+      const { dateScheduled, teamTypeId, requiredMemberIds, optionalMemberIds, wbsNum, meetingTimes } = req.body;
 
       const createdDesignReview = await DesignReviewsService.createDesignReview(
         submitter,
         dateScheduled,
         teamTypeId,
         requiredMemberIds,
         optionalMemberIds,
-        isOnline,
-        isInPerson,
-        docTemplateLink,
         wbsNum,
-        meetingTimes,
-        zoomLink,
-        location
+        meetingTimes
       );
       return res.status(200).json(createdDesignReview);
     } catch (error: unknown) {
@@ -78,8 +70,8 @@ export default class DesignReviewsController {
       const {
         dateScheduled,
         teamType,
-        requiredMembers,
-        optionalMembers,
+        requiredMembersIds,
+        optionalMembersIds,
         isOnline,
         isInPerson,
         zoomLink,
@@ -100,8 +92,8 @@ export default class DesignReviewsController {
         designReviewId,
         dateScheduled,
         teamType.teamTypeId,
-        requiredMembers,
-        optionalMembers,
+        requiredMembersIds,
+        optionalMembersIds,
         isOnline,
         isInPerson,
         zoomLink,
@@ -116,4 +108,18 @@ export default class DesignReviewsController {
       next(error);
     }
   }
+
+  // Mark the current user as confirmed for the given design review
+  static async markUserConfirmed(req: Request, res: Response, next: NextFunction) {
+    try {
+      const { availability } = req.body;
+      const { designReviewId } = req.params;
+      const user = await getCurrentUser(res);
+
+      const updatedDesignReview = await DesignReviewsService.markUserConfirmed(designReviewId, availability, user);
+      return res.status(200).json(updatedDesignReview);
+    } catch (error: unknown) {
+      next(error);
+    }
+  }
 }

src/backend/src/routes/design-reviews.routes.ts

@@ -7,6 +7,8 @@ const designReviewsRouter = express.Router();
 
 designReviewsRouter.get('/', DesignReviewsController.getAllDesignReviews);
 
+designReviewsRouter.get('/teamType/all', DesignReviewsController.getAllTeamTypes);
+
 designReviewsRouter.delete('/:designReviewId/delete', DesignReviewsController.deleteDesignReview);
 designReviewsRouter.get('/:designReviewId', DesignReviewsController.getSingleDesignReview);
 
@@ -18,12 +20,9 @@ designReviewsRouter.post(
   intMinZero(body('requiredMemberIds.*')),
   body('optionalMemberIds').isArray(),
   intMinZero(body('optionalMemberIds.*')),
-  nonEmptyString(body('location').optional()),
-  body('isOnline').isBoolean(),
-  body('isInPerson').isBoolean(),
-  nonEmptyString(body('zoomLink').optional()),
-  nonEmptyString(body('docTemplateLink')).optional(),
-  body('wbsNum'),
+  intMinZero(body('wbsNum.carNumber')),
+  intMinZero(body('wbsNum.projectNumber')),
+  intMinZero(body('wbsNum.workPackageNumber')),
   body('meetingTimes').isArray(),
   intMinZero(body('meetingTimes.*')),
   validateInputs,
@@ -52,4 +51,12 @@ designReviewsRouter.post(
   DesignReviewsController.editDesignReviews
 );
 
+designReviewsRouter.post(
+  '/:designReviewId/confirm-schedule',
+  body('availability').isArray(),
+  intMinZero(body('availability.*')),
+  validateInputs,
+  DesignReviewsController.markUserConfirmed
+);
+
 export default designReviewsRouter;

src/backend/src/services/design-reviews.services.ts

@@ -1,5 +1,5 @@
 import { Design_Review_Status, User } from '@prisma/client';
-import { DesignReview, WbsNumber, isAdmin, isLeadership, isNotLeadership } from 'shared';
+import { DesignReview, TeamType, WbsNumber, isAdmin, isLeadership, isNotLeadership } from 'shared';
 import prisma from '../prisma/prisma';
 import {
   NotFoundException,
@@ -10,7 +10,7 @@ import {
   AccessDeniedException
 } from '../utils/errors.utils';
 import { getUsers, getPrismaQueryUserIds } from '../utils/users.utils';
-import { validateMeetingTimes } from '../utils/design-reviews.utils';
+import { isUserOnDesignReview, validateMeetingTimes } from '../utils/design-reviews.utils';
 import designReviewQueryArgs from '../prisma-query-args/design-reviews.query-args';
 import { designReviewTransformer } from '../transformers/design-reviews.transformer';
 import { sendSlackDesignReviewNotification } from '../utils/slack.utils';
@@ -27,6 +27,11 @@ export default class DesignReviewsService {
     return designReviews.map(designReviewTransformer);
   }
 
+  static async getAllTeamTypes(): Promise<TeamType[]> {
+    const teamTypes = await prisma.teamType.findMany();
+    return teamTypes;
+  }
+
   /**
    * Deletes a design review
    * @param submitter the user who deleted the design review
@@ -55,34 +60,24 @@ export default class DesignReviewsService {
   }
 
   /**
-   * Creates a design review
-   * @param submitter user who submitted the design review
+   * Create a design review
+   * @param submitter User submitting the design review
    * @param dateScheduled when the design review is scheduled for
-   * @param teamTypeId team type id of the design review
-   * @param requiredMemberIds ids of the required members to attend the design review
-   * @param optionalMemberIds ids of the optional members to attend the design reivew
-   * @param isOnline if design review is online
-   * @param isInPerson if design review is in person
-   * @param docTemplateLink link to the doc template
-   * @param wbsNum wbs number for the design review
-   * @param meetingTimes the meeting times for the design review
-   * @param zoomLink link for the zoom if design review is online
-   * @param location location of the design review if in person
-   * @returns a design review
+   * @param teamTypeId team type id
+   * @param requiredMemberIds ids of members who are required to go
+   * @param optionalMemberIds ids of members who do not have to go
+   * @param wbsNum wbs num related to the design review
+   * @param meetingTimes meeting times of the design review
+   * @returns a new design review
    */
   static async createDesignReview(
     submitter: User,
     dateScheduled: Date,
     teamTypeId: string,
     requiredMemberIds: number[],
     optionalMemberIds: number[],
-    isOnline: boolean,
-    isInPerson: boolean,
-    docTemplateLink: string,
     wbsNum: WbsNumber,
-    meetingTimes: number[],
-    zoomLink?: string,
-    location?: string
+    meetingTimes: number[]
   ): Promise<DesignReview> {
     if (!isLeadership(submitter.role)) throw new AccessDeniedException('create design review');
 
@@ -125,14 +120,6 @@ export default class DesignReviewsService {
       }
     }
 
-    if (isOnline && !zoomLink) {
-      throw new HttpException(400, 'If the design review is online then there needs to be a zoom link');
-    }
-
-    if (isInPerson && !location) {
-      throw new HttpException(400, 'If the design review is in person then there needs to be a location');
-    }
-
     if (dateScheduled.valueOf() < new Date().valueOf()) {
       throw new HttpException(400, 'Design review cannot be scheduled for a past day');
     }
@@ -142,11 +129,8 @@ export default class DesignReviewsService {
         dateScheduled,
         dateCreated: new Date(),
         status: Design_Review_Status.UNCONFIRMED,
-        location,
-        isOnline,
-        isInPerson,
-        zoomLink,
-        docTemplateLink,
+        isOnline: false,
+        isInPerson: false,
         userCreated: { connect: { userId: submitter.userId } },
         teamType: { connect: { teamTypeId: teamType.teamTypeId } },
         requiredMembers: { connect: requiredMemberIds.map((memberId) => ({ userId: memberId })) },
@@ -178,7 +162,11 @@ export default class DesignReviewsService {
     for (const memberUserSetting of memberUserSettings) {
       if (memberUserSetting.slackId) {
         try {
-          await sendSlackDesignReviewNotification(memberUserSetting.slackId, designReview.designReviewId);
+          await sendSlackDesignReviewNotification(
+            memberUserSetting.slackId,
+            designReview.designReviewId,
+            designReview.wbsElement.name
+          );
         } catch (err: unknown) {
           if (err instanceof Error) {
             throw new HttpException(500, `Failed to send slack notification: ${err.message}`);
@@ -316,4 +304,76 @@ export default class DesignReviewsService {
     });
     return designReviewTransformer(updateDesignReview);
   }
+
+  /**
+   * Edits a design review by confirming a given user's availability and also updating their schedule settings with the given availability
+   * @param submitter the member that is being confirmed
+   * @param designReviewId the id of the design review
+   * @param availability the given member's availabilities
+   * @returns the modified design review with its updated confirmedMembers
+   */
+  static async markUserConfirmed(designReviewId: string, availability: number[], submitter: User): Promise<DesignReview> {
+    const designReview = await prisma.design_Review.findUnique({
+      where: { designReviewId },
+      ...designReviewQueryArgs
+    });
+
+    if (!designReview) throw new NotFoundException('Design Review', designReviewId);
+
+    if (designReview.dateDeleted) throw new DeletedException('Design Review', designReviewId);
+
+    if (!isUserOnDesignReview(submitter, designReviewTransformer(designReview)))
+      throw new HttpException(400, 'Current user is not in the list of this design reviews members');
+
+    availability.forEach((time) => {
+      if (time < 0 || time > 83) {
+        throw new HttpException(400, 'Availability times have to be in range 0-83');
+      }
+    });
+
+    await prisma.schedule_Settings.upsert({
+      where: { userId: submitter.userId },
+      update: {
+        availability
+      },
+      create: {
+        userId: submitter.userId,
+        personalGmail: '',
+        personalZoomLink: '',
+        availability
+      }
+    });
+
+    // set submitter as confirmed if they're not already
+    if (!designReview.confirmedMembers.map((user) => user.userId).includes(submitter.userId)) {
+      const updatedDesignReview = await prisma.design_Review.update({
+        where: { designReviewId },
+        ...designReviewQueryArgs,
+        data: {
+          confirmedMembers: {
+            connect: {
+              userId: submitter.userId
+            }
+          }
+        }
+      });
+
+      // If all requested attendees have confirmed their schedule, mark design review as confirmed
+      if (
+        updatedDesignReview.confirmedMembers.length ===
+        designReview.requiredMembers.length + designReview.optionalMembers.length
+      ) {
+        await prisma.design_Review.update({
+          where: { designReviewId },
+          ...designReviewQueryArgs,
+          data: {
+            status: Design_Review_Status.CONFIRMED
+          }
+        });
+      }
+
+      return designReviewTransformer(updatedDesignReview);
+    }
+    return designReviewTransformer(designReview);
+  }
 }

src/backend/src/utils/design-reviews.utils.ts

@@ -1,18 +1,25 @@
+import { DesignReview, User } from 'shared';
 import { HttpException } from './errors.utils';
 
 /**
  * Validate meeting times
  * @param nums the meeting times
  * @returns the meeting times
  */
-export function validateMeetingTimes(nums: number[]): number[] {
-  for (let i = 1; i < nums.length; i++) {
+export const validateMeetingTimes = (nums: number[]): number[] => {
+  for (let i = 0; i < nums.length; i++) {
     if (nums[i] < 0 || nums[i] > 83) {
-      throw new HttpException(400, 'meeting time must be between 0-83');
+      throw new HttpException(400, 'Meeting times have to be in range 0-83');
     }
-    if (nums[i] !== nums[i - 1] + 1) {
-      throw new HttpException(400, 'meeting times must be consecutive');
+    if (i > 0 && nums[i] !== nums[i - 1] + 1) {
+      throw new HttpException(400, 'Meeting times have to be consecutive');
     }
   }
   return nums;
-}
+};
+
+export const isUserOnDesignReview = (user: User, designReview: DesignReview): boolean => {
+  const requiredMembers = designReview.requiredMembers.map((user) => user.userId);
+  const optionalMembers = designReview.optionalMembers.map((user) => user.userId);
+  return requiredMembers.includes(user.userId) || optionalMembers.includes(user.userId);
+};

src/backend/src/utils/slack.utils.ts

@@ -91,11 +91,15 @@ export const sendReimbursementRequestDeniedNotification = async (slackId: string
   }
 };
 
-export const sendSlackDesignReviewNotification = async (slackId: string, designReviewId: string) => {
+export const sendSlackDesignReviewNotification = async (
+  slackId: string,
+  designReviewId: string,
+  designReviewName: string
+) => {
   if (process.env.NODE_ENV !== 'production') return; // don't send msgs unless in prod
-  const msg = `You have been invited to a Design Review!`;
-  const fullLink = `https://finishlinebyner.com/design-reviews/${designReviewId}`;
-  const linkButtonText = 'RSVP for the Design Review';
+  const msg = `You have been invited to the ${designReviewName} Design Review!`;
+  const fullLink = `https://finishlinebyner.com/settings/preferences?drId=${designReviewId}`;
+  const linkButtonText = 'Confirm Availability';
 
   try {
     await sendMessage(slackId, msg, fullLink, linkButtonText);