121 lines
3.8 KiB
TypeScript
121 lines
3.8 KiB
TypeScript
import { globalEmitter } from '$lib/server/globalEmitter';
|
|
import { eq } from 'drizzle-orm';
|
|
import { db } from '$lib/server/db';
|
|
import * as schema from '$lib/server/db/schema';
|
|
import { getRegisteredEvents } from '$lib/server/databaseManager';
|
|
|
|
export async function POST({ request }: any) {
|
|
// Decode body
|
|
let responseBody = await request.json();
|
|
|
|
// If there is no request then dont respond
|
|
if (!responseBody) {
|
|
return new Error('nuh uh');
|
|
} else {
|
|
console.log(JSON.stringify(responseBody));
|
|
if (responseBody.eventId) {
|
|
// Get the event
|
|
let eventData = await getRegisteredEvents(responseBody.eventId);
|
|
|
|
// If the event hasnt started or ended
|
|
if (eventData.events[0].state != 1) {
|
|
return new Error();
|
|
}
|
|
let scoringPreset = eventData.events[0].scoringPreset;
|
|
|
|
// make a new main ledger entry
|
|
let newLedgerEntry = await db
|
|
.insert(schema.mainLedger)
|
|
.values({ registeredEvent: responseBody.eventId })
|
|
.returning();
|
|
|
|
// get the id so i can use it in the sub ledgers
|
|
let ledgerEntryId = newLedgerEntry[0].id;
|
|
|
|
function getPoints(
|
|
scoringPreset: { placement: number; points: number }[] | string,
|
|
position: number
|
|
): number {
|
|
const preset =
|
|
typeof scoringPreset === 'string' ? JSON.parse(scoringPreset) : scoringPreset;
|
|
return (
|
|
preset.find((s: { placement: number; points: number }) => s.placement === position)
|
|
?.points ?? 0
|
|
);
|
|
}
|
|
|
|
// Create a Map to collect total scores per team
|
|
const teamScores = new Map<any, number>();
|
|
|
|
// for every bracket
|
|
for (let bracket in responseBody.brackets) {
|
|
// for every player
|
|
for (let player in responseBody.brackets[bracket].players) {
|
|
// variable fun
|
|
let currentPlayer = responseBody.brackets[bracket].players[player];
|
|
let currentPlayerTeam = currentPlayer.teamId;
|
|
let currentPlayerPosition = currentPlayer.position;
|
|
|
|
// If they put in a score / result
|
|
if (currentPlayerPosition > 0) {
|
|
let score = getPoints(scoringPreset, currentPlayerPosition);
|
|
// If their score is in the preset and they put in a score
|
|
if (currentPlayer.scores.length > 0) {
|
|
if (score > 0) {
|
|
// Accumulate points for this team instead of inserting right away
|
|
const currentTeamScore = teamScores.get(currentPlayerTeam) || 0;
|
|
teamScores.set(currentPlayerTeam, currentTeamScore + score);
|
|
}
|
|
|
|
// PLACEMENT LOGIC (Left untouched)
|
|
let newPlayerPlacement = await db
|
|
.update(schema.registeredPlayers)
|
|
.set({ placement: currentPlayerPosition })
|
|
.where(eq(schema.registeredPlayers.id, currentPlayer.registeredPlayerId))
|
|
.returning();
|
|
console.log(newPlayerPlacement[0].placement, currentPlayer.firstName);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
// After calculating all player scores, batch insert team scores into the ledger
|
|
if (teamScores.size > 0) {
|
|
const ledgerEntries = Array.from(teamScores.entries()).map(([teamID, points]) => ({
|
|
ledgerID: ledgerEntryId,
|
|
teamID,
|
|
points
|
|
}));
|
|
|
|
let newScores = await db.insert(schema.scoreLedger).values(ledgerEntries).returning();
|
|
console.log(newScores);
|
|
}
|
|
|
|
// 2. Determine the winner right here using the same Map data
|
|
let highestScore = -1;
|
|
let winningTeamId = null;
|
|
|
|
for (let [teamID, points] of teamScores.entries()) {
|
|
if (points > highestScore) {
|
|
highestScore = points;
|
|
winningTeamId = teamID;
|
|
}
|
|
}
|
|
|
|
if (winningTeamId) {
|
|
let teamWinnerUpdate = await db
|
|
.update(schema.registeredEvents)
|
|
.set({ teamWinner: winningTeamId, state: 2, timeCompleted: Date.now() })
|
|
.where(eq(schema.registeredEvents.id, responseBody.eventId))
|
|
.returning();
|
|
console.log(teamWinnerUpdate);
|
|
}
|
|
}
|
|
|
|
// Update the frontends
|
|
globalEmitter.emit('scoreUpdate');
|
|
// Return a response because
|
|
return new Response('coolsies');
|
|
}
|
|
}
|