118 lines
3.6 KiB
TypeScript
118 lines
3.6 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) {
|
|
let responseBody = await request.json();
|
|
|
|
if (!responseBody) {
|
|
return new Error('nuh uh');
|
|
} else {
|
|
if (responseBody.eventId) {
|
|
let eventData = await getRegisteredEvents(responseBody.eventId);
|
|
|
|
if (eventData.events[0].state != 1) {
|
|
return new Error();
|
|
}
|
|
let scoringPreset = eventData.events[0].scoringPreset;
|
|
|
|
// Create ledger entry to record this scoring event
|
|
let newLedgerEntry = await db
|
|
.insert(schema.mainLedger)
|
|
.values({ registeredEvent: responseBody.eventId })
|
|
.returning();
|
|
|
|
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
|
|
);
|
|
}
|
|
|
|
// Accumulate scores per team, then batch insert
|
|
const teamScores = new Map<any, number>();
|
|
|
|
for (let bracket in responseBody.brackets) {
|
|
for (let player in responseBody.brackets[bracket].players) {
|
|
let currentPlayer = responseBody.brackets[bracket].players[player];
|
|
let currentPlayerTeam = currentPlayer.teamId;
|
|
let currentPlayerPosition = currentPlayer.position;
|
|
|
|
if (currentPlayerPosition > 0) {
|
|
let score = getPoints(scoringPreset, currentPlayerPosition);
|
|
if (currentPlayer.scores.length > 0) {
|
|
if (score > 0) {
|
|
const currentTeamScore = teamScores.get(currentPlayerTeam) || 0;
|
|
teamScores.set(currentPlayerTeam, currentTeamScore + score);
|
|
}
|
|
|
|
for (let result in currentPlayer.scores) {
|
|
let currentResult = currentPlayer.scores[result];
|
|
let newScoreEntry = await db
|
|
.insert(schema.registeredResults)
|
|
.values({
|
|
registeredPlayerId: currentPlayer.registeredPlayerId,
|
|
resultIndex: parseInt(result),
|
|
result: currentResult
|
|
})
|
|
.returning();
|
|
console.log(newScoreEntry);
|
|
}
|
|
|
|
// Update player placement in the database
|
|
let newPlayerPlacement = await db
|
|
.update(schema.registeredPlayers)
|
|
.set({ placement: currentPlayerPosition })
|
|
.where(eq(schema.registeredPlayers.id, currentPlayer.registeredPlayerId))
|
|
.returning();
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
// 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();
|
|
}
|
|
|
|
// Determine the winning team from accumulated scores
|
|
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();
|
|
}
|
|
}
|
|
|
|
globalEmitter.emit('scoreUpdate');
|
|
globalEmitter.emit('eventUpdate');
|
|
return new Response('coolsies');
|
|
}
|
|
}
|