resolve merge conflicts

Author: Maggie Chen

backend/typescript/graphql/index.ts

@@ -15,6 +15,8 @@ import simpleEntityResolvers from "./resolvers/simpleEntityResolvers";
 import simpleEntityType from "./types/simpleEntityType";
 import userResolvers from "./resolvers/userResolvers";
 import userType from "./types/userType";
+import reviewDashboardResolvers from "./resolvers/reviewDashboardResolvers";
+import reviewDashboardType from "./types/reviewDashboardType";
 
 const query = gql`
   type Query {
@@ -29,12 +31,21 @@ const mutation = gql`
 `;
 
 const executableSchema = makeExecutableSchema({
-  typeDefs: [query, mutation, authType, entityType, simpleEntityType, userType],
+  typeDefs: [
+    query,
+    mutation,
+    authType,
+    entityType,
+    simpleEntityType,
+    userType,
+    reviewDashboardType,
+  ],
   resolvers: merge(
     authResolvers,
     entityResolvers,
     simpleEntityResolvers,
     userResolvers,
+    reviewDashboardResolvers,
   ),
 });
 

backend/typescript/graphql/resolvers/reviewDashboardResolvers.ts

@@ -0,0 +1,25 @@
+import ReviewDashboardService from "../../services/implementations/reviewDashboardService";
+import { ReviewDashboardRowDTO } from "../../types";
+import { getErrorMessage } from "../../utilities/errorUtils";
+
+const reviewDashboardService = new ReviewDashboardService();
+
+const reviewDashboardResolvers = {
+  Query: {
+    reviewDashboard: async (
+      _parent: undefined,
+      args: { pageNumber: number; resultsPerPage: number },
+    ): Promise<ReviewDashboardRowDTO[]> => {
+      try {
+        return await reviewDashboardService.getReviewDashboard(
+          args.pageNumber,
+          args.resultsPerPage,
+        );
+      } catch (error) {
+        throw new Error(getErrorMessage(error));
+      }
+    },
+  },
+};
+
+export default reviewDashboardResolvers;

backend/typescript/graphql/types/reviewDashboardType.ts

@@ -0,0 +1,29 @@
+import { gql } from "apollo-server-express";
+import { ApplicationStatus, PositionTitle, ReviewerDTO } from "../../types";
+
+const reviewDashboardType = gql`
+  type ReviewerDTO {
+    firstName: String!
+    lastName: String!
+  }
+
+  type ReviewDashboardRowDTO {
+    firstName: String!
+    lastName: String!
+    position: String!
+    timesApplied: String!
+    applicationStatus: String!
+    choice: Int!
+    reviewers: [ReviewerDTO!]!
+    totalScore: Int
+  }
+
+  extend type Query {
+    reviewDashboard(
+      pageNumber: Int!
+      resultsPerPage: Int!
+    ): [ReviewDashboardRowDTO!]!
+  }
+`;
+
+export default reviewDashboardType;

backend/typescript/migrations/20251004173456-add-reviewer-has-conflict-column.ts

@@ -0,0 +1,20 @@
+import { DataType } from "sequelize-typescript";
+import { Migration } from "../umzug";
+
+const TABLE_NAME = "reviewed_applicant_records";
+
+export const up: Migration = async ({ context: sequelize }) => {
+  await sequelize
+    .getQueryInterface()
+    .addColumn(TABLE_NAME, "reviewerHasConflict", {
+      type: DataType.BOOLEAN,
+      allowNull: false,
+      defaultValue: false,
+    });
+};
+
+export const down: Migration = async ({ context: sequelize }) => {
+  await sequelize
+    .getQueryInterface()
+    .removeColumn(TABLE_NAME, "reviewerHasConflict");
+};

backend/typescript/migrations/20251004173612-update-db-with-scores-col.ts

@@ -0,0 +1,29 @@
+import { DataType } from "sequelize-typescript";
+import { Migration } from "../umzug";
+
+const REV_APP_TABLE = "reviewed_applicant_records";
+const APP_TABLE = "applicant_records";
+
+export const up: Migration = async ({ context: sequelize }) => {
+  await sequelize.getQueryInterface().addColumn(REV_APP_TABLE, "score", {
+    type: DataType.INTEGER,
+    allowNull: true,
+    defaultValue: null,
+  });
+
+  await sequelize.getQueryInterface().addColumn(APP_TABLE, "combined_score", {
+    type: DataType.INTEGER,
+    allowNull: true,
+    defaultValue: null,
+  });
+};
+
+export const down: Migration = async ({ context: sequelize }) => {
+  await sequelize
+    .getQueryInterface()
+    .removeColumn("reviewed_applicant_records", "score");
+
+  await sequelize
+    .getQueryInterface()
+    .removeColumn("applicant_records", "combined_score");
+};

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,19 +1,23 @@
 /* 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 {
@@ -23,7 +27,7 @@ export default class ApplicantRecord extends Model {
     unique: true,
     autoIncrement: true,
   })
-  id!: string;
+  id!: number;
 
   @ForeignKey(() => Applicant)
   @Column({ type: DataType.STRING })
@@ -48,6 +52,19 @@ export default class ApplicantRecord extends Model {
   @Column({ type: DataType.JSONB, allowNull: true })
   extraInfo!: ApplicantRecordExtraInfo;
 
+  @Column({
+    type: DataType.INTEGER,
+    allowNull: true,
+    defaultValue: null,
+  })
+  combined_score!: number;
+
   @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

@@ -6,10 +6,12 @@ import {
   ForeignKey,
   Model,
   Table,
+  BelongsTo,
 } from "sequelize-typescript";
-import User from "./user.model";
+import { NonAttribute } from "sequelize";
 import { Review, ReviewStatus, ReviewStatusEnum } from "../types";
 import ApplicantRecord from "./applicantRecord.model";
+import User from "./user.model";
 
 @Table({ tableName: "reviewed_applicant_records" })
 export default class ReviewedApplicantRecord extends Model {
@@ -29,4 +31,20 @@ export default class ReviewedApplicantRecord extends Model {
     defaultValue: ReviewStatusEnum.TODO,
   })
   status!: ReviewStatus;
+
+  @Column({
+    type: DataType.INTEGER,
+    allowNull: true,
+    defaultValue: null,
+  })
+  score!: number;
+
+  @Column({
+    type: DataType.BOOLEAN,
+    defaultValue: false,
+  })
+  reviewerHasConflict!: boolean;
+
+  @BelongsTo(() => User, { foreignKey: "reviewerId", targetKey: "id" })
+  user?: NonAttribute<User>;
 }

backend/typescript/models/user.model.ts

@@ -8,8 +8,10 @@ import {
   Model,
   Table,
 } from "sequelize-typescript";
+import { NonAttribute } from "sequelize";
 import { PositionTitle, PositionTitles, Role } from "../types";
 import Position from "./position.model";
+import ReviewedApplicantRecord from "./reviewedApplicantRecord.model";
 
 @Table({ tableName: "users" })
 export default class User extends Model {
@@ -34,4 +36,13 @@ export default class User extends Model {
   @ForeignKey(() => Position)
   @Column({ type: DataType.ENUM(...Object.values(PositionTitles)) })
   position?: PositionTitle;
+
+  @HasMany(() => ApplicationDashboardTable)
+  applicationDashboards?: ApplicationDashboardTable[];
+
+  @HasMany(() => ReviewedApplicantRecord, {
+    foreignKey: "reviewerId",
+    as: "user",
+  })
+  reviewedApplicantRecords?: NonAttribute<ReviewedApplicantRecord[]>;
 }

backend/typescript/services/implementations/reviewDashboardService.ts

@@ -0,0 +1,77 @@
+import { PositionTitle, ReviewDashboardRowDTO } from "../../types";
+import IReviewDashboardService from "../interfaces/IReviewDashboardService";
+import { getErrorMessage } from "../../utilities/errorUtils";
+import logger from "../../utilities/logger";
+import ApplicantRecord from "../../models/applicantRecord.model";
+
+const Logger = logger(__filename);
+
+function toDTO(model: ApplicantRecord): ReviewDashboardRowDTO {
+  return {
+    firstName: model.applicant!.firstName,
+    lastName: model.applicant!.lastName,
+    position: model.position as PositionTitle,
+    timesApplied: model.applicant!.timesApplied.toString(),
+    applicationStatus: model.status,
+    choice: model.choice,
+    reviewers: model.reviewedApplicantRecords!.map((r) => ({
+      firstName: r.user!.first_name,
+      lastName: r.user!.last_name,
+    })),
+    totalScore: model.combined_score,
+  };
+}
+
+class ReviewDashboardService implements IReviewDashboardService {
+  /* eslint-disable class-methods-use-this */
+  async getReviewDashboard(
+    pageNumber: number,
+    resultsPerPage: number,
+  ): Promise<ReviewDashboardRowDTO[]> {
+    try {
+      const perPage = Number.isFinite(Number(resultsPerPage))
+        ? Number(resultsPerPage)
+        : 1;
+      const currentPage = Number.isFinite(Number(pageNumber))
+        ? Number(pageNumber)
+        : 1;
+      const offsetRow = (currentPage - 1) * perPage;
+
+      // get applicant_record
+      // JOIN applicant ON applicant_id
+      // JOIN reviewed_applicant_record ON applicant_record_id
+      // JOIN user ON reviewer_id
+      const applicants: Array<ApplicantRecord> | null =
+        await ApplicantRecord.findAll({
+          attributes: { exclude: ["createdAt", "updatedAt"] },
+          include: [
+            {
+              attributes: { exclude: ["createdAt", "updatedAt"] },
+              association: "reviewedApplicantRecords",
+              include: [
+                {
+                  attributes: { exclude: ["createdAt", "updatedAt"] },
+                  association: "user",
+                },
+              ],
+            },
+            {
+              attributes: { exclude: ["createdAt", "updatedAt"] },
+              association: "applicant",
+            },
+          ],
+          order: [["id", "ASC"]],
+          limit: perPage,
+          offset: offsetRow,
+        });
+      return applicants.map(toDTO);
+    } catch (error: unknown) {
+      Logger.error(
+        `Failed to get dashboard. Reason = ${getErrorMessage(error)}`,
+      );
+      throw error;
+    }
+  }
+}
+
+export default ReviewDashboardService;