- first changes

Author: ruiichen

backend/typescript/graphql/index.ts

@@ -18,6 +18,8 @@ import userType from "./types/userType";
 import dashboardType from "./types/dashboardType";
 import dashboardResolvers from "./resolvers/dashboardResolvers";
 import reviewType from "./types/reviewType";
+import reviewPageType from "./types/reviewPageType";
+import reviewPageResolvers from "./resolvers/reviewPageResolvers";
 
 const query = gql`
   type Query {
@@ -41,13 +43,15 @@ const executableSchema = makeExecutableSchema({
     simpleEntityType,
     userType,
     dashboardType,
+    reviewPageType,
   ],
   resolvers: merge(
     authResolvers,
     entityResolvers,
     simpleEntityResolvers,
     userResolvers,
     dashboardResolvers,
+    reviewPageResolvers,
   ),
 });
 

backend/typescript/graphql/resolvers/reviewPageResolvers.ts

@@ -0,0 +1,24 @@
+import { ApplicationDTO } from "../../types";
+import ReviewPageService from "../../services/implementations/reviewPageService";
+import { getErrorMessage } from "../../utilities/errorUtils";
+
+const reviewPageService = new ReviewPageService();
+
+const reviewPageResolvers = {
+  Query: {
+    reviewApplicantPage: async (
+      _parent: undefined,
+      args: { reviewedApplicantRecordId: number },
+    ): Promise<ApplicationDTO[]> => {
+      try {
+        return await reviewPageService.getReviewPage(
+          args.reviewedApplicantRecordId,
+        );
+      } catch (error) {
+        throw new Error(getErrorMessage(error));
+      }
+    },
+  },
+};
+
+export default reviewPageResolvers;

backend/typescript/graphql/types/reviewPageType.ts

@@ -0,0 +1,9 @@
+import { gql } from "apollo-server-express";
+
+const reviewPageType = gql`
+  extend type Query {
+    reviewApplicantPage(reviewedApplicantRecordId: Int!): [ApplicationDTO!]!
+  }
+`;
+
+export default reviewPageType;

backend/typescript/models/applicant.model.ts

@@ -1,6 +1,8 @@
 /* eslint import/no-cycle: 0 */
 
-import { Column, DataType, Model, Table } from "sequelize-typescript";
+import { Column, DataType, HasMany, Model, Table } from "sequelize-typescript";
+import { NonAttribute } from "sequelize";
+import ApplicantRecord from "./applicantRecord.model";
 
 @Table({ tableName: "applicants" })
 export default class Applicant extends Model {
@@ -10,7 +12,7 @@ export default class Applicant extends Model {
     unique: true,
     autoIncrement: true,
   })
-  id!: string;
+  id!: number;
 
   @Column({ type: DataType.STRING })
   academicOrCoop!: string;
@@ -53,4 +55,10 @@ export default class Applicant extends Model {
 
   @Column({ type: DataType.DATE })
   submittedAt!: Date;
+
+  @HasMany(() => ApplicantRecord, {
+    foreignKey: "id",
+    as: "applicant",
+  })
+  applicantRecords?: NonAttribute<ApplicantRecord[]>;
 }

backend/typescript/models/applicantRecord.model.ts

@@ -1,33 +1,37 @@
 /* eslint import/no-cycle: 0 */
 
 import {
+  BelongsTo,
   Column,
   DataType,
   ForeignKey,
+  HasMany,
   Model,
   Table,
 } from "sequelize-typescript";
+import { NonAttribute } from "sequelize";
 import {
   ApplicantRecordExtraInfo,
   ApplicationStatus,
   SkillCategory,
 } from "../types";
 import Applicant from "./applicant.model";
 import Position from "./position.model";
+import ReviewedApplicantRecord from "./reviewedApplicantRecord.model";
 
 @Table({ tableName: "applicant_records" })
 export default class ApplicantRecord extends Model {
   @Column({
-    type: DataType.INTEGER,
+    type: DataType.STRING,
     primaryKey: true,
     unique: true,
     autoIncrement: true,
   })
   id!: string;
 
   @ForeignKey(() => Applicant)
-  @Column({ type: DataType.STRING })
-  applicantId!: string;
+  @Column({ type: DataType.INTEGER })
+  applicantId!: number;
 
   @ForeignKey(() => Position)
   @Column({ type: DataType.STRING })
@@ -57,4 +61,10 @@ export default class ApplicantRecord extends Model {
 
   @Column({ type: DataType.BOOLEAN, defaultValue: false })
   isApplicantFlagged!: boolean;
+
+  @BelongsTo(() => Applicant, "applicantId")
+  applicant?: NonAttribute<Applicant>;
+
+  @HasMany(() => ReviewedApplicantRecord, "applicantRecordId")
+  reviewedApplicantRecords?: NonAttribute<ReviewedApplicantRecord[]>;
 }

backend/typescript/models/reviewedApplicantRecord.model.ts

@@ -15,7 +15,7 @@ import User from "./user.model";
 export default class ReviewedApplicantRecord extends Model {
   @ForeignKey(() => ApplicantRecord)
   @Column({ type: DataType.STRING, primaryKey: true })
-  applicantRecordId!: number;
+  applicantRecordId!: string;
 
   @ForeignKey(() => User)
   @Column({ type: DataType.INTEGER, primaryKey: true })

backend/typescript/services/implementations/reviewPageService.ts

@@ -0,0 +1,89 @@
+import { ApplicationDTO } from "../../types";
+import IReviewPageService from "../interfaces/IReviewPageService";
+import { getErrorMessage } from "../../utilities/errorUtils";
+import logger from "../../utilities/logger";
+import ApplicantRecord from "../../models/applicantRecord.model";
+import ReviewedApplicantRecord from "../../models/reviewedApplicantRecord.model";
+import Applicant from "../../models/applicant.model";
+
+const Logger = logger(__filename);
+
+function toDTO(model: Applicant): ApplicationDTO {
+  const firstChoice = model.applicantRecords!.find((ar) => ar.choice === 1);
+  const secondChoice = model.applicantRecords!.find((ar) => ar.choice === 2);
+
+  return {
+    id: model.id,
+    academicOrCoop: model.academicOrCoop,
+    academicYear: model.academicYear,
+    email: model.email,
+    firstChoiceRole: firstChoice!.position,
+    firstName: model.firstName,
+    lastName: model.lastName,
+    heardFrom: model.heardFrom,
+    locationPreference: model.locationPreference,
+    program: model.program,
+    timesApplied: model.timesApplied.toString(),
+    pronouns: model.pronouns,
+    pronounsSpecified: "",
+    resumeUrl: model.resumeUrl,
+    roleSpecificQuestions: firstChoice!.roleSpecificQuestions,
+    secondChoiceRole: secondChoice ? secondChoice.position : "",
+    shortAnswerQuestions: model.shortAnswerQuestions,
+    status: firstChoice!.status,
+    term: model.term,
+    secondChoiceStatus: secondChoice ? secondChoice.status : "",
+    timestamp: BigInt(1728673405),
+  };
+}
+
+class ReviewPageService implements IReviewPageService {
+  /* eslint-disable class-methods-use-this */
+  async getReviewPage(
+    reviewedApplicantRecordId: number,
+  ): Promise<ApplicationDTO[]> {
+    try {
+      // get applicant ids first
+      const rARs: Array<ReviewedApplicantRecord> =
+        await ReviewedApplicantRecord.findAll({
+          where: { applicantRecordId: reviewedApplicantRecordId },
+          attributes: { exclude: ["createdAt", "updatedAt"] },
+        });
+      if (rARs.length === 0)
+        throw new Error(
+          `ReviewedApplicantRecords with ID ${reviewedApplicantRecordId} not found.`,
+        );
+
+      const aRIds: Array<number> = [
+        ...new Set(rARs.map((r) => r.applicantRecordId)),
+      ];
+      const aRs: Array<ApplicantRecord> = await ApplicantRecord.findAll({
+        where: { id: aRIds },
+        attributes: { exclude: ["createdAt", "updatedAt"] },
+      });
+      if (aRs.length === 0)
+        throw new Error(`Database integrity has been violated`);
+
+      const aIds: Array<number> = [...new Set(aRs.map((a) => a.applicantId))];
+      const as: Array<Applicant> = await Applicant.findAll({
+        where: { id: aIds },
+        attributes: { exclude: ["createdAt", "updatedAt"] },
+        include: [
+          {
+            attributes: { exclude: ["createdAt", "updatedAt"] },
+            association: "applicantRecords",
+          },
+        ],
+      });
+      if (as.length === 0)
+        throw new Error(`Database integrity has been violated`);
+
+      return as.map(toDTO);
+    } catch (error: unknown) {
+      Logger.error(`Failed to fetch. Reason = ${getErrorMessage(error)}`);
+      throw error;
+    }
+  }
+}
+
+export default ReviewPageService;

backend/typescript/services/interfaces/IReviewPageService.ts

@@ -0,0 +1,11 @@
+import { ApplicationDTO } from "../../types";
+
+interface IReviewPageService {
+  /**
+   * Fetch data from the Applicant and ApplicantRecord table to return an ApplicationDTO object
+   * @Param reviewedApplicantRecordId the id of the applicant record that the viewer is interested in
+   */
+  getReviewPage(reviewedApplicantRecordId: number): Promise<ApplicationDTO[]>;
+}
+
+export default IReviewPageService;

backend/typescript/types.ts

@@ -52,7 +52,6 @@ export type ApplicationDashboardInput = Omit<
   "applicationId"
 >;
 
-// DEPRECATED - TO BE REMOVED AT THE END OF S25
 export type ApplicationDTO = {
   id: number;
   academicOrCoop: string;