Merge pull request #61 from HackDavis/feat/team-grouping

Feat/team grouping

Author: brandonw504

app/(api)/_actions/judgeSubmissions/updateSubmission.ts

@@ -1,8 +1,8 @@
 'use server';
 import FormToJSON from '@utils/form/FormToJSON';
-import { updateSubmission } from '@datalib/submissions/updateSubmission';
+import { UpdateSubmission } from '@datalib/submissions/updateSubmission';
 
-export default async function UpdateSubmission(formData: FormData) {
+export default async function updateSubmission(formData: FormData) {
   const { judge_id, team_id, ...rest } = FormToJSON(formData);
-  await updateSubmission(judge_id, team_id, rest);
+  await UpdateSubmission(judge_id, team_id, rest);
 }

app/(api)/_actions/logic/groupJudges.ts

@@ -0,0 +1,3 @@
+'use server';
+
+export default async function groupJudges() {}

app/(api)/_actions/logic/matchTeams.ts

@@ -0,0 +1,12 @@
+'use server';
+import { GetManyJudgeGroups } from '@datalib/judgeGroups/getJudgeGroup';
+import { GetManyTeams } from '@datalib/teams/getTeam';
+import { LinkManyJudgeGroupsToTeams } from '@datalib/judgeGroups/linkJudgeGroupToTeam';
+import matchingAlgorithm from '@utils/grouping/matchingAlgorithm';
+
+export default async function matchTeams() {
+  const judgeGroups = await (await GetManyJudgeGroups()).json();
+  const teams = await (await GetManyTeams()).json();
+  const matches = matchingAlgorithm(judgeGroups.body, teams.body);
+  LinkManyJudgeGroupsToTeams(matches);
+}

app/(api)/_actions/logic/pairJudges.ts

@@ -3,10 +3,46 @@ import { ObjectId } from 'mongodb';
 
 import { getDatabase } from '@utils/mongodb/mongoClient.mjs';
 import isBodyEmpty from '@utils/request/isBodyEmpty';
+import parseAndReplace from '@utils/request/parseAndReplace';
 import NoContentError from '@utils/response/NoContentError';
 import HttpError from '@utils/response/HttpError';
 import { NotFoundError, DuplicateError } from '@utils/response/Errors';
 
+export const LinkManyJudgeGroupsToTeams = async (body: object[]) => {
+  try {
+    if (isBodyEmpty(body)) {
+      throw new NoContentError();
+    }
+
+    const parsedBody = parseAndReplace(body);
+
+    const db = await getDatabase();
+    const creationStatus = await db
+      .collection('judgeGroupToTeams')
+      .insertMany(parsedBody);
+
+    const links = await db
+      .collection('judgeGroupToTeams')
+      .find({
+        _id: {
+          $in: Object.values(creationStatus.insertedIds).map((id: any) => id),
+        },
+      })
+      .toArray();
+
+    return NextResponse.json(
+      { ok: true, body: await links, error: null },
+      { status: 201 }
+    );
+  } catch (e) {
+    const error = e as HttpError;
+    return NextResponse.json(
+      { ok: false, body: null, error: error.message },
+      { status: error.status || 400 }
+    );
+  }
+};
+
 export const LinkJudgeGroupToTeam = async (body: {
   judge_group_id: string;
   team_id: string;

app/(api)/_datalib/judgeGroups/linkJudgeGroupToTeam.ts

@@ -8,7 +8,7 @@ import HttpError from '@utils/response/HttpError';
 import parseAndReplace from '@utils/request/parseAndReplace';
 import { NotFoundError, DuplicateError } from '@utils/response/Errors';
 
-export const createSubmission = async (body: {
+export const CreateSubmission = async (body: {
   judge_id: string;
   team_id: string;
 }) => {

app/(api)/_datalib/submissions/createSubmission.ts

@@ -5,7 +5,7 @@ import { getDatabase } from '@utils/mongodb/mongoClient.mjs';
 import NotFoundError from '@utils/response/NotFoundError';
 import HttpError from '@utils/response/HttpError';
 
-export const deleteSubmission = async (judge_id: string, team_id: string) => {
+export const DeleteSubmission = async (judge_id: string, team_id: string) => {
   try {
     const judge_object_id = new ObjectId(judge_id);
     const team_object_id = new ObjectId(team_id);

app/(api)/_datalib/submissions/deleteSubmission.ts

@@ -3,7 +3,7 @@ import { getDatabase } from '@utils/mongodb/mongoClient.mjs';
 import HttpError from '@utils/response/HttpError';
 import { ObjectId } from 'mongodb';
 
-export const getSubmissions = async (query: object = {}) => {
+export const GetManySubmissions = async (query: object = {}) => {
   try {
     const db = await getDatabase();
     const submissions = await db
@@ -24,7 +24,7 @@ export const getSubmissions = async (query: object = {}) => {
   }
 };
 
-export const getSubmission = async (judge_id: string, team_id: string) => {
+export const GetSubmission = async (judge_id: string, team_id: string) => {
   try {
     const judge_object_id = new ObjectId(judge_id);
     const team_object_id = new ObjectId(team_id);

app/(api)/_datalib/submissions/getSubmissions.ts

@@ -8,7 +8,7 @@ import isBodyEmpty from '@utils/request/isBodyEmpty';
 import parseAndReplace from '@utils/request/parseAndReplace';
 import NoContentError from '@utils/response/NoContentError';
 
-export const updateSubmission = async (
+export const UpdateSubmission = async (
   judge_id: string,
   team_id: string,
   body: object

app/(api)/_datalib/submissions/updateSubmission.ts

@@ -10,7 +10,7 @@ import {
 import Team from '@typeDefs/teams';
 import tracks from '../../_data/tracks.json' assert { type: 'json' };
 
-export const createTeams = async (body: object[]) => {
+export const CreateManyTeams = async (body: object[]) => {
   try {
     if (isBodyEmpty(body)) {
       throw new NoContentError();

app/(api)/_datalib/teams/createTeams.ts

@@ -5,7 +5,7 @@ import { getDatabase } from '@utils/mongodb/mongoClient.mjs';
 import NotFoundError from '@utils/response/NotFoundError';
 import HttpError from '@utils/response/HttpError';
 
-export const deleteTeam = async (id: string) => {
+export const DeleteTeam = async (id: string) => {
   try {
     const object_id = new ObjectId(id);
     const db = await getDatabase();

app/(api)/_datalib/teams/deleteTeam.ts

@@ -3,7 +3,7 @@ import { getDatabase } from '@utils/mongodb/mongoClient.mjs';
 import { HttpError, NotFoundError } from '@utils/response/Errors';
 import { ObjectId } from 'mongodb';
 
-export const getTeam = async (id: string) => {
+export const GetTeam = async (id: string) => {
   try {
     const object_id = new ObjectId(id);
     const db = await getDatabase();
@@ -28,7 +28,7 @@ export const getTeam = async (id: string) => {
   }
 };
 
-export const getTeams = async (query: object = {}) => {
+export const GetManyTeams = async (query: object = {}) => {
   try {
     const db = await getDatabase();
     const teams = await db

app/(api)/_datalib/teams/getTeam.ts

@@ -11,7 +11,7 @@ import {
   NotFoundError,
 } from '@utils/response/Errors';
 
-export const updateTeam = async (id: string, body: object) => {
+export const UpdateTeam = async (id: string, body: object) => {
   try {
     const object_id = new ObjectId(id);
     if (isBodyEmpty(body)) {

app/(api)/_datalib/teams/updateTeam.ts

@@ -19,7 +19,7 @@ const Team = {
     },
     tracks: {
       bsonType: 'array',
-      maxItems: 4,
+      maxItems: 5,
       items: {
         enum: tracks.map((track) => track.name),
         description: 'track must be one of the valid tracks',

app/(api)/_schema/Team.mjs

@@ -1,6 +1,6 @@
 import Judge from '@typeDefs/judges';
 
-export default function groupJudges(judges: Judge[]) {
+export default function groupingAlgorithm(judges: Judge[]) {
   const techJudges = judges.filter((judge) => judge.specialty === 'tech');
   const generalJudges = judges.filter((judge) => judge.specialty === 'general');
   const desJudges = judges.filter((judge) => judge.specialty === 'design');

app/(api)/_utils/grouping/groupJudges.ts renamed to app/(api)/_utils/grouping/groupingAlgorithm.ts

@@ -0,0 +1,99 @@
+import JudgeGroup from '@typeDefs/judgeGroups';
+import Team from '@typeDefs/teams';
+import tracks from '../../_data/tracks.json' assert { type: 'json' };
+
+interface Match {
+  judge_group_id: string;
+  team_id: string;
+}
+
+function createMatches(
+  judgeGroups: JudgeGroup[],
+  teams: Team[],
+  type: string,
+  rounds: number
+) {
+  const matches: Match[] = [];
+
+  judgeGroups.forEach((judgeGroup) => {
+    let count = 0;
+    for (const team of teams) {
+      if (count == rounds) break;
+      for (const chosenTrack in team.tracks) {
+        if (judgeGroup._id == undefined) continue;
+        const foundTrack = tracks.find((track) => track.name === chosenTrack);
+        if (foundTrack == undefined) continue;
+
+        if (foundTrack.type === type) {
+          matches.push({
+            judge_group_id: judgeGroup._id,
+            team_id: team._id,
+          });
+          count++;
+        }
+      }
+    }
+  });
+
+  return matches;
+}
+
+export default function matchingAlgorithm(
+  judgeGroups: JudgeGroup[],
+  teams: Team[]
+) {
+  const techGroups = judgeGroups.filter((group) => group.type === 'T');
+  const generalGroups = judgeGroups.filter((group) => group.type === 'G');
+  const designGroups = judgeGroups.filter((group) => group.type === 'D');
+
+  let totalTech = 0;
+  let totalGeneral = 0;
+  let totalDesign = 0;
+
+  teams.forEach((team) => {
+    team.tracks.forEach((chosenTrack) => {
+      const foundTrack = tracks.find((track) => track.name === chosenTrack);
+
+      if (
+        foundTrack == undefined ||
+        foundTrack.name === 'Best Hack for Social Good'
+      ) {
+        return;
+      }
+
+      switch (foundTrack!.type) {
+        case 'tech':
+          totalTech++;
+          break;
+        case 'general':
+          totalGeneral++;
+          break;
+        case 'design':
+          totalDesign++;
+          break;
+        default:
+          return;
+      }
+    });
+  });
+
+  const techRounds = Math.ceil(totalTech / techGroups.length);
+  const generalRounds = Math.ceil(totalGeneral / generalGroups.length);
+  const designRounds = Math.ceil(totalDesign / designGroups.length);
+
+  const techMatches = createMatches(techGroups, teams, 'tech', techRounds);
+  const generalMatches = createMatches(
+    generalGroups,
+    teams,
+    'general',
+    generalRounds
+  );
+  const designMatches = createMatches(
+    designGroups,
+    teams,
+    'design',
+    designRounds
+  );
+
+  return techMatches.concat(generalMatches, designMatches);
+}

app/(api)/_utils/grouping/matchingAlgorithm.ts

@@ -1,9 +1,9 @@
 import { NextRequest } from 'next/server';
-import { deleteSubmission } from '@datalib/submissions/deleteSubmission';
+import { DeleteSubmission } from '@datalib/submissions/deleteSubmission';
 
 export async function DELETE(
   _: NextRequest,
   { params }: { params: { judge_id: string; team_id: string } }
 ) {
-  return deleteSubmission(params.judge_id, params.team_id);
+  return DeleteSubmission(params.judge_id, params.team_id);
 }

app/(api)/api/submissions/[judge_id]/[team_id]/delete.ts

@@ -1,9 +1,9 @@
-import { getSubmission } from '@datalib/submissions/getSubmissions';
+import { GetSubmission } from '@datalib/submissions/getSubmissions';
 import { NextRequest } from 'next/server';
 
 export async function GET(
   _: NextRequest,
   { params }: { params: { judge_id: string; team_id: string } }
 ) {
-  return getSubmission(params.judge_id, params.team_id);
+  return GetSubmission(params.judge_id, params.team_id);
 }

app/(api)/api/submissions/[judge_id]/[team_id]/get.ts

@@ -1,10 +1,10 @@
 import { NextRequest } from 'next/server';
-import { updateSubmission } from '@datalib/submissions/updateSubmission';
+import { UpdateSubmission } from '@datalib/submissions/updateSubmission';
 
 export async function PUT(
   request: NextRequest,
   { params }: { params: { judge_id: string; team_id: string } }
 ) {
   const body = await request.json();
-  return updateSubmission(params.judge_id, params.team_id, body);
+  return UpdateSubmission(params.judge_id, params.team_id, body);
 }

app/(api)/api/submissions/[judge_id]/[team_id]/put.ts

@@ -1,9 +1,9 @@
 import { NextRequest } from 'next/server';
 
 import getQueries from '@utils/request/getQueries';
-import { getSubmissions } from '@datalib/submissions/getSubmissions';
+import { GetManySubmissions } from '@datalib/submissions/getSubmissions';
 
 export async function GET(request: NextRequest) {
   const queries = getQueries(request);
-  return getSubmissions(queries);
+  return GetManySubmissions(queries);
 }

app/(api)/api/submissions/get.ts

@@ -1,7 +1,7 @@
-import { createSubmission } from '@datalib/submissions/createSubmission';
+import { CreateSubmission } from '@datalib/submissions/createSubmission';
 import { NextRequest } from 'next/server';
 
 export async function POST(request: NextRequest) {
   const body = await request.json();
-  return createSubmission(body);
+  return CreateSubmission(body);
 }

app/(api)/api/submissions/post.ts

@@ -1,9 +1,9 @@
 import { type NextRequest } from 'next/server';
-import { deleteTeam } from '@datalib/teams/deleteTeam';
+import { DeleteTeam } from '@datalib/teams/deleteTeam';
 
 export async function DELETE(
   _: NextRequest,
   { params }: { params: { id: string } }
 ) {
-  return deleteTeam(params.id);
+  return DeleteTeam(params.id);
 }

app/(api)/api/teams/[id]/delete.ts

@@ -1,9 +1,9 @@
 import { type NextRequest } from 'next/server';
-import { getTeam } from '@datalib/teams/getTeam';
+import { GetTeam } from '@datalib/teams/getTeam';
 
 export async function GET(
   _: NextRequest,
   { params }: { params: { id: string } }
 ) {
-  return getTeam(params.id);
+  return GetTeam(params.id);
 }

app/(api)/api/teams/[id]/get.ts

@@ -1,10 +1,10 @@
 import { type NextRequest } from 'next/server';
-import { updateTeam } from '@datalib/teams/updateTeam';
+import { UpdateTeam } from '@datalib/teams/updateTeam';
 
 export async function PUT(
   request: NextRequest,
   { params }: { params: { id: string } }
 ) {
   const body = await request.json();
-  return updateTeam(params.id, body);
+  return UpdateTeam(params.id, body);
 }

app/(api)/api/teams/[id]/put.ts

@@ -1,9 +1,9 @@
 import { type NextRequest } from 'next/server';
 
 import getQueries from '@utils/request/getQueries';
-import { getTeams } from '@datalib/teams/getTeam';
+import { GetManyTeams } from '@datalib/teams/getTeam';
 
 export async function GET(request: NextRequest) {
   const queries = getQueries(request);
-  return getTeams(queries);
+  return GetManyTeams(queries);
 }