#4076: created getGuestDefinition endpoint

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

@@ -115,4 +115,18 @@ export default class RecruitmentController {
       next(error);
     }
   }
+
+  static async getGuestDefinition(req: Request, res: Response, next: NextFunction) {
+    try {
+      const { userCreatedId, organizationId, definitionId } = req.params as {
+        userCreatedId: string;
+        organizationId: string;
+        definitionId: string;
+      };
+      const definition = await RecruitmentServices.getGuestDefinition(userCreatedId, organizationId, definitionId);
+      res.status(200).json(definition);
+    } catch (error: unknown) {
+      next(error);
+    }
+  }
 }

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

@@ -62,4 +62,6 @@ recruitmentRouter.post(
   RecruitmentController.createGuestDefinition
 );
 
+recruitmentRouter.get('/guestDefinition/:id', RecruitmentController.getGuestDefinition);
+
 export default recruitmentRouter;

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

@@ -1,4 +1,4 @@
-import { Organization } from '@prisma/client';
+import { Guest_Definition, Organization } from '@prisma/client';
 import { isAdmin, User } from 'shared';
 import prisma from '../prisma/prisma.js';
 import { AccessDeniedAdminOnlyException, DeletedException, NotFoundException } from '../utils/errors.utils.js';
@@ -253,4 +253,28 @@ export default class RecruitmentServices {
 
     return definition;
   }
+
+  /**
+   * Gets a single guest defenition with the given user, organization, and definition ids
+   * @param userCreatedId the id of guest to retrieve
+   * @param organizationId the organization the user is currently in
+   * @param definitionId the id of the specific defenition being found
+   * @returns a definition
+   * @throws if the defenition is not found in the db
+   */
+  static async getGuestDefinition(
+    userCreatedId: string,
+    organizationId: string,
+    definitionId: string
+  ): Promise<Guest_Definition> {
+    const guest = await prisma.guest_Definition.findFirst({
+      where: { userCreatedId, organizationId, definitionId }
+    });
+
+    if (!guest) {
+      throw new NotFoundException('User', userCreatedId);
+    }
+
+    return guest;
+  }
 }

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

@@ -377,4 +377,33 @@ describe('Recruitment Tests', () => {
       ).rejects.toThrow(new AccessDeniedAdminOnlyException('create a guest definition'));
     });
   });
+
+  describe('Get a single guest defenition', () => {
+    it('Get a single team type works', async () => {
+      const guestDefinition = await RecruitmentServices.createGuestDefinition(
+        superman,
+        organization,
+        'test term',
+        'test description',
+        2,
+        'iconname',
+        'buttonTxt',
+        'buttonLink'
+      );
+      const result = await RecruitmentServices.getGuestDefinition(
+        guestDefinition.userCreatedId,
+        orgId,
+        guestDefinition.definitionId
+      );
+      expect(result).toStrictEqual(guestDefinition);
+    });
+
+    it('Get a single guest defenition fails', async () => {
+      const nonExistingGuestId = 'nonExistingGuest';
+      const nonExistingDefinitionId = 'nonExistingDefinition';
+      await expect(async () =>
+        RecruitmentServices.getGuestDefinition(nonExistingGuestId, orgId, nonExistingDefinitionId)
+      ).rejects.toThrow(new NotFoundException('User', nonExistingGuestId));
+    });
+  });
 });