Merge pull request #4081 from Northeastern-Electric-Racing/#3936-delete-guest-definition

#3936 delete guest definition

Author: chpy04

src/backend/src/controllers/recruitment.controllers.ts

@@ -116,6 +116,16 @@ export default class RecruitmentController {
     }
   }
 
+  static async deleteGuestDefinition(req: Request, res: Response, next: NextFunction) {
+    try {
+      const { definitionId } = req.params as Record<string, string>;
+      await RecruitmentServices.deleteGuestDefinition(req.currentUser, definitionId, req.organization);
+      res.status(200).json({ message: `Successfully deleted guestDefinition with id ${definitionId}` });
+    } catch (error: unknown) {
+      next(error);
+    }
+  }
+
   static async getAllGuestDefintions(req: Request, res: Response, next: NextFunction) {
     try {
       const allDefinitons = await RecruitmentServices.getAllGuestDefinitions(req.organization);

src/backend/src/prisma/seed.ts

@@ -3892,6 +3892,17 @@ const performSeed: () => Promise<void> = async () => {
     undefined
   );
 
+  /* Guest Definitions */
+  const guestDef1 = await prisma.guest_Definition.create({
+    data: {
+      term: 'NER',
+      description: 'A really awesome organization!',
+      order: 0,
+      organizationId,
+      userCreatedId: batman.userId
+    }
+  });
+
   await RecruitmentServices.createGuestDefinition(
     thomasEmrax,
     ner,

src/backend/src/routes/recruitment.routes.ts

@@ -50,6 +50,8 @@ recruitmentRouter.post(
 
 recruitmentRouter.delete('/faq/:faqId/delete', RecruitmentController.deleteFaq);
 
+/* Guest Definition Section */
+
 recruitmentRouter.post(
   '/guestdefinition/create',
   nonEmptyString(body('term')),
@@ -62,6 +64,7 @@ recruitmentRouter.post(
   RecruitmentController.createGuestDefinition
 );
 
+recruitmentRouter.delete('/guestdefinition/:definitionId/delete', RecruitmentController.deleteGuestDefinition);
 recruitmentRouter.get('/guestdefinitions', RecruitmentController.getAllGuestDefintions);
 
 export default recruitmentRouter;

src/backend/src/services/recruitment.services.ts

@@ -261,4 +261,25 @@ export default class RecruitmentServices {
 
     return allGuestDefintions.map(guestDefinitionTransformer);
   }
+
+  /**
+   * Deletes a guestDefinition with the given organization Id and definitionId
+   * @param deleter the user requesting to delete the guestDefinition
+   * @param organizationId the organization ID of the deleter
+   */
+  static async deleteGuestDefinition(deleter: User, definitionId: string, organization: Organization): Promise<void> {
+    if (!(await userHasPermission(deleter.userId, organization.organizationId, isAdmin))) {
+      throw new AccessDeniedAdminOnlyException('delete a guestDefinition');
+    }
+
+    const def = await prisma.guest_Definition.findUnique({ where: { definitionId } });
+
+    if (!def) throw new NotFoundException('Guest Definition', definitionId);
+    if (def.dateDeleted) throw new DeletedException('Guest Definition', definitionId);
+
+    await prisma.guest_Definition.update({
+      where: { definitionId },
+      data: { dateDeleted: new Date(), userDeletedId: deleter.userId }
+    });
+  }
 }

src/backend/src/utils/errors.utils.ts

@@ -211,6 +211,7 @@ export type ExceptionObjectNames =
   | 'Event Type'
   | 'Event'
   | 'Schedule Slot'
+  | 'Guest Definition'
   | 'ProspectiveSponsor'
   | 'SponsorTier'
   | 'Meeting Attendance';

src/backend/tests/test-utils.ts

@@ -945,3 +945,20 @@ export const createMinimalPartReviewForReview = async (
 
   return { review, partId: part.partId };
 };
+
+export const createTestGuestDefinition = async (user: User, organizationId: string) => {
+  if (!organizationId) organizationId = await createTestOrganization().then((org) => org.organizationId);
+  if (!organizationId) throw new Error('Failed to create organization');
+
+  const def = await prisma.guest_Definition.create({
+    data: {
+      term: 'Term',
+      description: 'Description',
+      order: 0,
+      organizationId,
+      userCreatedId: user.userId
+    }
+  });
+
+  return def;
+};

src/backend/tests/unit/recruitment.test.ts

@@ -3,6 +3,7 @@ import { Organization, User } from '@prisma/client';
 import RecruitmentServices from '../../src/services/recruitment.services.js';
 import { AccessDeniedAdminOnlyException, DeletedException, NotFoundException } from '../../src/utils/errors.utils.js';
 import {
+  createTestGuestDefinition,
   createTestMilestone,
   createTestFaq,
   createTestFAQ,
@@ -341,6 +342,7 @@ describe('Recruitment Tests', () => {
       expect(deletedTestFaq?.dateDeleted).not.toBe(null);
     });
   });
+
   describe('Create Guest Definitions', () => {
     it('Successful guest definition creation', async () => {
       const def = await RecruitmentServices.createGuestDefinition(
@@ -378,6 +380,49 @@ describe('Recruitment Tests', () => {
     });
   });
 
+  describe('Delete Guest Definition', () => {
+    it('Fails if user is not an admin', async () => {
+      const admin = await createTestUser(batmanAppAdmin, orgId);
+      const guest = await createTestUser(wonderwomanGuest, orgId);
+      const testDef = await createTestGuestDefinition(admin, orgId);
+
+      await expect(
+        async () => await RecruitmentServices.deleteGuestDefinition(guest, testDef.definitionId, organization)
+      ).rejects.toThrow(new AccessDeniedAdminOnlyException('delete a guestDefinition'));
+    });
+
+    it('Fails if definition does not exist', async () => {
+      const admin = await createTestUser(batmanAppAdmin, orgId);
+
+      await expect(
+        async () => await RecruitmentServices.deleteGuestDefinition(admin, 'fake-id', organization)
+      ).rejects.toThrow(new NotFoundException('Guest Definition', 'fake-id'));
+    });
+
+    it('Fails if definition is already deleted', async () => {
+      const admin = await createTestUser(batmanAppAdmin, orgId);
+      const testDef = await createTestGuestDefinition(admin, orgId);
+      await RecruitmentServices.deleteGuestDefinition(admin, testDef.definitionId, organization);
+
+      await expect(
+        async () => await RecruitmentServices.deleteGuestDefinition(admin, testDef.definitionId, organization)
+      ).rejects.toThrow(new DeletedException('Guest Definition', testDef.definitionId));
+    });
+
+    it('Successfully deletes a guest definition', async () => {
+      const admin = await createTestUser(batmanAppAdmin, orgId);
+      const testDef = await createTestGuestDefinition(admin, orgId);
+
+      await RecruitmentServices.deleteGuestDefinition(admin, testDef.definitionId, organization);
+
+      const deletedTestDef = await prisma.guest_Definition.findUnique({
+        where: { definitionId: testDef.definitionId }
+      });
+
+      expect(deletedTestDef?.dateDeleted).not.toBe(null);
+    });
+  });
+
   describe('Get All Guest Definitions', () => {
     it('Succeeds and gets all the guest definitions', async () => {
       const def = await RecruitmentServices.createGuestDefinition(