[INTF25] Implement Delegation Algorithm & Mutator

backend/typescript/graphql/resolvers/reviewDashboardResolvers.ts

@@ -2,6 +2,7 @@ import ReviewDashboardService from "../../services/implementations/reviewDashboa
 import {
   ReviewDashboardRowDTO,
   ReviewDashboardSidePanelDTO,
+  ReviewedApplicantRecordDTO,
 } from "../../types";
 import { getErrorMessage } from "../../utilities/errorUtils";
 
@@ -35,6 +36,18 @@ const reviewDashboardResolvers = {
       }
     },
   },
+  Mutation: {
+    delegateReviewers: async (
+      _parent: undefined,
+      args: { positions: string[] },
+    ): Promise<ReviewedApplicantRecordDTO[]> => {
+      try {
+        return await reviewDashboardService.delegateReviewers(args.positions);
+      } catch (error) {
+        throw new Error(getErrorMessage(error));
+      }
+    },
+  },
 };
 
 export default reviewDashboardResolvers;

backend/typescript/graphql/types/reviewDashboardType.ts

@@ -1,4 +1,12 @@
 import { gql } from "apollo-server-express";
+import {
+  ApplicationStatus,
+  PositionTitle,
+  Review,
+  ReviewerDTO,
+  ReviewStatus,
+  SkillCategory,
+} from "../../types";
 
 const reviewDashboardType = gql`
   type ReviewerDTO {
@@ -17,13 +25,13 @@
     totalScore: Int
   }
 
-  type Review {
-    passionFSG: Int
-    teamPlayer: Int
-    desireToLearn: Int
-    skill: Int
-    skillCategory: String
-    comments: String
+  type ReviewedApplicantRecordDTO {
+    applicantRecordId: String!
+    reviewerId: Int!
+    review: Review
+    status: String!
+    score: Int
+    reviewerHasConflict: Boolean!
   }
 
   type ReviewDetails {
@@ -51,6 +59,10 @@
 
     reviewDashboardSidePanel(applicantId: String!): ReviewDashboardSidePanelDTO!
   }
+
+  extend type Mutation {
+    delegateReviewers(positions: [String!]!): [ReviewedApplicantRecordDTO!]!
+  }
 `;
 
 export default reviewDashboardType;

backend/typescript/services/implementations/reviewDashboardService.ts

@@ -1,15 +1,22 @@
+import { Op } from "sequelize";
 import {
-  PositionTitle,
   ReviewDashboardRowDTO,
+  ReviewedApplicantRecordDTO,
+  CreateReviewedApplicantRecordDTO,
   ReviewDashboardSidePanelDTO,
+  PositionTitle,
 } from "../../types";
 import IReviewDashboardService from "../interfaces/IReviewDashboardService";
 import { getErrorMessage } from "../../utilities/errorUtils";
 import logger from "../../utilities/logger";
 import ApplicantRecord from "../../models/applicantRecord.model";
+import User from "../../models/user.model";
+import ReviewedApplicantRecordService from "./reviewedApplicantRecordService";
 
 const Logger = logger(__filename);
 
+const reviewedApplicantRecordService = new ReviewedApplicantRecordService();
+
 function toDTO(model: ApplicantRecord): ReviewDashboardRowDTO {
   return {
     firstName: model.applicant!.firstName,
@@ -137,6 +144,111 @@ class ReviewDashboardService implements IReviewDashboardService {
       throw error;
     }
   }
+
+  async delegateReviewers(
+    positions: string[],
+  ): Promise<ReviewedApplicantRecordDTO[]> {
+    // NOTE: We do not have to concern ourselves with locality. That is, each user can be
+    //       assigned to the same partner every time.
+
+    const delegations = Array<CreateReviewedApplicantRecordDTO>();
+    // maps (applicant_record_id) => pair of user_ids assigned to it
+
+    // STEP 1:
+    //   Populate the FSM
+    //   NOTE: need to add a sentinel value at the end of the list if the number of user is odd.
+    //         The last 'real' user will bear the burden of solo reviewing.
+
+    // Get users and group by position
+    const groups = (
+      await User.findAll({
+        attributes: { exclude: ["createdAt", "updatedAt"] },
+        where: { position: { [Op.in]: positions } },
+      })
+    ).reduce((map, user) => {
+      // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+      const pos = user.position!;
+      const arr = map.get(pos) ?? [];
+      arr.push(user.id);
+      map.set(pos, arr);
+      return map;
+    }, new Map<string, number[]>());
+
+    // Build FSM
+    // maps (position title) => (current index of list, list of users with position_title)
+    const FSM = new Map<string, [number, (number | undefined)[]]>(
+      positions.map((title) => [title, [0, groups.get(title) ?? []]]),
+    );
+
+    // Validate FSM for correctness
+    Array.from(FSM.entries()).forEach(([title, [, userIds]]) => {
+      if (userIds.length === 0) {
+        // no users with this position
+        throw new Error(`Invalid amount of users with position ${title}.`);
+      }
+      if (userIds.length % 2 !== 0) {
+        // sentinel value of undefined at the end
+        userIds.push(undefined);
+      }
+    });
+
+    // STEP 2:
+    //   Round robin with the FSM
+    /*
+    for (auto& a : applicant_records) {
+      pair<int,vector<string>>& position_entry = FSM[a.position];
+
+      // get first user
+      string id1 = position_entry.second[position_entry.first];
+      position_entry.first++;
+      position_entry.first %= position_entry.second.size();
+
+      // get second user
+      string id2 = position_entry.second[position_entry.first];
+      position_entry.first++;
+      position_entry.first %= position_entry.second.size();
+
+      delegations[a.id] = make_pair(id1, id2);
+    }
+     */
+    const applicantRecords = await ApplicantRecord.findAll({
+      attributes: { exclude: ["createdAt", "updatedAt"] },
+      where: { position: { [Op.in]: positions } },
+    });
+    applicantRecords.forEach((record) => {
+      /* eslint-disable @typescript-eslint/no-non-null-assertion */
+      const [count, userIds] = FSM.get(record.position)!;
+      let newCount = count;
+      const assignedReviewer1 = FSM.get(record.position)![1][newCount];
+      newCount++;
+      newCount %= FSM.get(record.position)![1].length;
+      const assignedReviewer2 = FSM.get(record.position)![1][newCount];
+      newCount++;
+      newCount %= FSM.get(record.position)![1].length;
+      FSM.set(record.position, [newCount, userIds]);
+
+      if (assignedReviewer1 !== undefined) {
+        delegations.push({
+          applicantRecordId: record.id,
+          reviewerId: assignedReviewer1,
+        });
+      }
+
+      if (assignedReviewer2 !== undefined) {
+        delegations.push({
+          applicantRecordId: record.id,
+          reviewerId: assignedReviewer2,
+        });
+      }
+    });
+
+    // STEP 3:
+    //   Batch the delegations into ReviewedApplicantRecords
+    //   NOTE: do not add the sentinel value we inserted earlier.
+    return reviewedApplicantRecordService.bulkCreateReviewedApplicantRecord(
+      delegations,
+    );
+  }
 }
 
 export default ReviewDashboardService;

backend/typescript/services/interfaces/IReviewDashboardService.ts

@@ -1,6 +1,7 @@
 import {
   ReviewDashboardRowDTO,
   ReviewDashboardSidePanelDTO,
+  ReviewedApplicantRecordDTO,
 } from "../../types";
 
 interface IReviewDashboardService {
@@ -14,6 +15,13 @@ interface IReviewDashboardService {
     resultsPerPage: number,
   ): Promise<ReviewDashboardRowDTO[]>;
 
+  /**
+   * Assigns each user to an applicant record to review, and
+   * returns the newly created ReviewedApplicantRecords
+   * @Param positions the list of positions the algorithm should run on
+   */
+  delegateReviewers(positions: string[]): Promise<ReviewedApplicantRecordDTO[]>;
+
   /**
    * Fetch data that can fill out the review dashboard side panel for an applicant
    * @Param applicantId the ID of the applicant