460 lines
13 KiB
TypeScript
460 lines
13 KiB
TypeScript
import { database } from "~/database/context";
|
|
import * as schema from "~/database/schema";
|
|
import { eq, and, desc, sql } from "drizzle-orm";
|
|
|
|
/**
|
|
* Default qualifying point values (as specified in scoring-system.md)
|
|
*/
|
|
export const DEFAULT_QP_VALUES = [
|
|
{ placement: 1, points: 20 },
|
|
{ placement: 2, points: 14 },
|
|
{ placement: 3, points: 10 },
|
|
{ placement: 4, points: 8 },
|
|
{ placement: 5, points: 5 },
|
|
{ placement: 6, points: 5 },
|
|
{ placement: 7, points: 3 },
|
|
{ placement: 8, points: 3 },
|
|
{ placement: 9, points: 2 },
|
|
{ placement: 10, points: 2 },
|
|
{ placement: 11, points: 2 },
|
|
{ placement: 12, points: 2 },
|
|
{ placement: 13, points: 1 },
|
|
{ placement: 14, points: 1 },
|
|
{ placement: 15, points: 1 },
|
|
{ placement: 16, points: 1 },
|
|
];
|
|
|
|
export interface QualifyingPointConfigData {
|
|
placement: number;
|
|
points: number;
|
|
}
|
|
|
|
export function roundQualifyingPoints(points: number): number {
|
|
return Math.round((points + Number.EPSILON) * 100) / 100;
|
|
}
|
|
|
|
/**
|
|
* Given a participant's awarded QP before and after a re-score, return the ids
|
|
* whose QP changed. A row's `qp` is the raw decimal string (or null when no QP
|
|
* was awarded). A participant counts as changed when their new value differs from
|
|
* the old, including a first-time score (null → value). Participants absent from
|
|
* `after` are not reported (their removal is handled by the caller's recalc).
|
|
*
|
|
* Shared by the two QP re-score paths — processQualifyingEvent (sibling windows,
|
|
* CS2, manual admin) and rescoreTennisBracketAndDetectChanges (tennis primary) —
|
|
* so the "only announce real changes" semantics live in one place.
|
|
*/
|
|
export function diffChangedQualifyingPoints(
|
|
before: Iterable<{ id: string; qp: string | null }>,
|
|
after: Iterable<{ id: string; qp: string | null }>
|
|
): Set<string> {
|
|
const beforeQP = new Map<string, number>();
|
|
for (const r of before) {
|
|
if (r.qp !== null) beforeQP.set(r.id, parseFloat(r.qp));
|
|
}
|
|
const changed = new Set<string>();
|
|
for (const r of after) {
|
|
if (r.qp === null) continue;
|
|
if (beforeQP.get(r.id) !== parseFloat(r.qp)) changed.add(r.id);
|
|
}
|
|
return changed;
|
|
}
|
|
|
|
export function calculateSplitQualifyingPoints(
|
|
placement: number,
|
|
tieCount: number,
|
|
pointsByPlacement: Map<number, number>
|
|
): number {
|
|
if (placement <= 0 || tieCount <= 0) return 0;
|
|
|
|
let totalQP = 0;
|
|
for (let pos = placement; pos < placement + tieCount; pos++) {
|
|
totalQP += pointsByPlacement.get(pos) ?? 0;
|
|
}
|
|
|
|
return roundQualifyingPoints(totalQP / tieCount);
|
|
}
|
|
|
|
export function hasProcessedQualifyingPlacement(
|
|
results: Array<{
|
|
placement?: number | null;
|
|
qualifyingPointsAwarded?: string | null;
|
|
}>
|
|
): boolean {
|
|
return results.some(
|
|
(result) =>
|
|
result.placement !== null &&
|
|
result.placement !== undefined &&
|
|
result.qualifyingPointsAwarded !== null &&
|
|
result.qualifyingPointsAwarded !== undefined
|
|
);
|
|
}
|
|
|
|
/**
|
|
* Initialize default qualifying point configuration for a sports season
|
|
*/
|
|
export async function initializeQPConfig(
|
|
sportsSeasonId: string,
|
|
providedDb?: ReturnType<typeof database>
|
|
) {
|
|
const db = providedDb || database();
|
|
|
|
// Check if config already exists
|
|
const existing = await db.query.qualifyingPointConfig.findMany({
|
|
where: eq(schema.qualifyingPointConfig.sportsSeasonId, sportsSeasonId),
|
|
});
|
|
|
|
if (existing.length > 0) {
|
|
return existing;
|
|
}
|
|
|
|
// Insert default config
|
|
const configs = await db
|
|
.insert(schema.qualifyingPointConfig)
|
|
.values(
|
|
DEFAULT_QP_VALUES.map((qp) => ({
|
|
sportsSeasonId,
|
|
placement: qp.placement,
|
|
points: qp.points.toString(),
|
|
}))
|
|
)
|
|
.returning();
|
|
|
|
return configs;
|
|
}
|
|
|
|
/**
|
|
* Get qualifying point configuration for a sports season
|
|
*/
|
|
export async function getQPConfig(
|
|
sportsSeasonId: string,
|
|
providedDb?: ReturnType<typeof database>
|
|
) {
|
|
const db = providedDb || database();
|
|
|
|
const configs = await db.query.qualifyingPointConfig.findMany({
|
|
where: eq(schema.qualifyingPointConfig.sportsSeasonId, sportsSeasonId),
|
|
orderBy: [schema.qualifyingPointConfig.placement],
|
|
});
|
|
|
|
// If no config exists, initialize with defaults
|
|
if (configs.length === 0) {
|
|
return await initializeQPConfig(sportsSeasonId, db);
|
|
}
|
|
|
|
return configs;
|
|
}
|
|
|
|
/**
|
|
* Update qualifying point configuration for a sports season
|
|
*/
|
|
export async function updateQPConfig(
|
|
sportsSeasonId: string,
|
|
configData: QualifyingPointConfigData[],
|
|
providedDb?: ReturnType<typeof database>
|
|
) {
|
|
const db = providedDb || database();
|
|
|
|
// Delete existing config
|
|
await db
|
|
.delete(schema.qualifyingPointConfig)
|
|
.where(eq(schema.qualifyingPointConfig.sportsSeasonId, sportsSeasonId));
|
|
|
|
// Insert new config
|
|
const configs = await db
|
|
.insert(schema.qualifyingPointConfig)
|
|
.values(
|
|
configData.map((qp) => ({
|
|
sportsSeasonId,
|
|
placement: qp.placement,
|
|
points: qp.points.toString(),
|
|
}))
|
|
)
|
|
.returning();
|
|
|
|
return configs;
|
|
}
|
|
|
|
/**
|
|
* Get qualifying points awarded for a specific placement
|
|
*/
|
|
export async function getQPForPlacement(
|
|
sportsSeasonId: string,
|
|
placement: number,
|
|
providedDb?: ReturnType<typeof database>
|
|
): Promise<number> {
|
|
const db = providedDb || database();
|
|
|
|
const config = await db.query.qualifyingPointConfig.findFirst({
|
|
where: and(
|
|
eq(schema.qualifyingPointConfig.sportsSeasonId, sportsSeasonId),
|
|
eq(schema.qualifyingPointConfig.placement, placement)
|
|
),
|
|
});
|
|
|
|
return config ? parseFloat(config.points) : 0;
|
|
}
|
|
|
|
/**
|
|
* Get or create participant qualifying total record
|
|
*/
|
|
export async function getOrCreateParticipantQPTotal(
|
|
participantId: string,
|
|
sportsSeasonId: string,
|
|
providedDb?: ReturnType<typeof database>
|
|
) {
|
|
const db = providedDb || database();
|
|
|
|
let total = await db.query.seasonParticipantQualifyingTotals.findFirst({
|
|
where: and(
|
|
eq(schema.seasonParticipantQualifyingTotals.participantId, participantId),
|
|
eq(schema.seasonParticipantQualifyingTotals.sportsSeasonId, sportsSeasonId)
|
|
),
|
|
});
|
|
|
|
if (!total) {
|
|
const [created] = await db
|
|
.insert(schema.seasonParticipantQualifyingTotals)
|
|
.values({
|
|
participantId,
|
|
sportsSeasonId,
|
|
totalQualifyingPoints: "0",
|
|
eventsScored: 0,
|
|
})
|
|
.returning();
|
|
total = created;
|
|
}
|
|
|
|
return total;
|
|
}
|
|
|
|
/**
|
|
* Add qualifying points to a participant's total
|
|
* NOTE: eventsScored is NOT updated here - it should be recalculated after processing events
|
|
*/
|
|
export async function addQualifyingPoints(
|
|
participantId: string,
|
|
sportsSeasonId: string,
|
|
pointsToAdd: number,
|
|
providedDb?: ReturnType<typeof database>
|
|
) {
|
|
const db = providedDb || database();
|
|
|
|
// Get or create the total record
|
|
const total = await getOrCreateParticipantQPTotal(participantId, sportsSeasonId, db);
|
|
|
|
// Update with new points (do NOT increment eventsScored here)
|
|
const [updated] = await db
|
|
.update(schema.seasonParticipantQualifyingTotals)
|
|
.set({
|
|
totalQualifyingPoints: (parseFloat(total.totalQualifyingPoints) + pointsToAdd).toString(),
|
|
updatedAt: new Date(),
|
|
})
|
|
.where(eq(schema.seasonParticipantQualifyingTotals.id, total.id))
|
|
.returning();
|
|
|
|
return updated;
|
|
}
|
|
|
|
/**
|
|
* Recalculate total QP and eventsScored for a participant from scratch
|
|
* This is the source of truth - sums all event_results with QP awarded
|
|
*/
|
|
export async function recalculateParticipantQP(
|
|
participantId: string,
|
|
sportsSeasonId: string,
|
|
providedDb?: ReturnType<typeof database>
|
|
) {
|
|
const db = providedDb || database();
|
|
|
|
// Get all event results for this participant in this sports season
|
|
const eventResults = await db.query.eventResults.findMany({
|
|
where: eq(schema.eventResults.seasonParticipantId, participantId),
|
|
with: {
|
|
scoringEvent: true,
|
|
},
|
|
});
|
|
|
|
// Calculate totals from event_results
|
|
let totalQP = 0;
|
|
const uniqueEvents = new Set<string>();
|
|
|
|
for (const result of eventResults) {
|
|
if (
|
|
result.scoringEvent.sportsSeasonId === sportsSeasonId &&
|
|
result.qualifyingPointsAwarded
|
|
) {
|
|
const qp = parseFloat(result.qualifyingPointsAwarded);
|
|
if (qp > 0) {
|
|
totalQP += qp;
|
|
uniqueEvents.add(result.scoringEvent.id);
|
|
}
|
|
}
|
|
}
|
|
|
|
const eventsScored = uniqueEvents.size;
|
|
|
|
// Get or create the participant's QP total record
|
|
const total = await getOrCreateParticipantQPTotal(participantId, sportsSeasonId, db);
|
|
|
|
// Update with recalculated values
|
|
await db
|
|
.update(schema.seasonParticipantQualifyingTotals)
|
|
.set({
|
|
totalQualifyingPoints: totalQP.toString(),
|
|
eventsScored,
|
|
updatedAt: new Date(),
|
|
})
|
|
.where(eq(schema.seasonParticipantQualifyingTotals.id, total.id));
|
|
|
|
return { totalQP, eventsScored };
|
|
}
|
|
|
|
/**
|
|
* Upsert qualifying points + placement into event_results for a set of participants,
|
|
* then recalculate each participant's QP total.
|
|
*
|
|
* Shared by the QP writers (assignCs2EliminationQP for Swiss-stage exits,
|
|
* processQualifyingBracketEvent for Champions-Stage / knockout brackets) so the
|
|
* upsert + recalc loop lives in one place. Upserts on
|
|
* (scoringEventId, seasonParticipantId), so repeated calls overwrite cleanly.
|
|
*
|
|
* @param entries Map from seasonParticipantId → { qp, placement } to write.
|
|
*/
|
|
export async function writeEventResultsQP(
|
|
scoringEventId: string,
|
|
sportsSeasonId: string,
|
|
entries: Map<string, { qp: number; placement: number }>,
|
|
providedDb?: ReturnType<typeof database>
|
|
): Promise<void> {
|
|
if (entries.size === 0) return;
|
|
const db = providedDb || database();
|
|
const now = new Date();
|
|
|
|
await Promise.all(
|
|
[...entries.entries()].map(([seasonParticipantId, { qp, placement }]) =>
|
|
db
|
|
.insert(schema.eventResults)
|
|
.values({
|
|
scoringEventId,
|
|
seasonParticipantId,
|
|
qualifyingPointsAwarded: qp.toFixed(2),
|
|
placement,
|
|
createdAt: now,
|
|
updatedAt: now,
|
|
})
|
|
.onConflictDoUpdate({
|
|
target: [schema.eventResults.scoringEventId, schema.eventResults.seasonParticipantId],
|
|
set: {
|
|
qualifyingPointsAwarded: qp.toFixed(2),
|
|
placement,
|
|
updatedAt: now,
|
|
},
|
|
})
|
|
)
|
|
);
|
|
|
|
await Promise.all(
|
|
[...entries.keys()].map((seasonParticipantId) =>
|
|
recalculateParticipantQP(seasonParticipantId, sportsSeasonId, db)
|
|
)
|
|
);
|
|
}
|
|
|
|
/**
|
|
* Recalculate eventsScored for a participant by counting unique events with QP awarded
|
|
* @deprecated Use recalculateParticipantQP instead for more accurate recalculation
|
|
*/
|
|
export async function recalculateEventsScored(
|
|
participantId: string,
|
|
sportsSeasonId: string,
|
|
providedDb?: ReturnType<typeof database>
|
|
) {
|
|
const result = await recalculateParticipantQP(participantId, sportsSeasonId, providedDb);
|
|
return result.eventsScored;
|
|
}
|
|
|
|
/**
|
|
* Get all qualifying totals for a sports season, ordered by points (highest first)
|
|
*/
|
|
export async function getQPStandings(
|
|
sportsSeasonId: string,
|
|
providedDb?: ReturnType<typeof database>
|
|
) {
|
|
const db = providedDb || database();
|
|
|
|
return await db.query.seasonParticipantQualifyingTotals.findMany({
|
|
where: eq(schema.seasonParticipantQualifyingTotals.sportsSeasonId, sportsSeasonId),
|
|
orderBy: [desc(sql`CAST(${schema.seasonParticipantQualifyingTotals.totalQualifyingPoints} AS DECIMAL)`)],
|
|
with: {
|
|
participant: true,
|
|
},
|
|
});
|
|
}
|
|
|
|
/**
|
|
* Update final rankings for qualifying point standings (after finalization)
|
|
*/
|
|
export async function updateFinalRankings(
|
|
sportsSeasonId: string,
|
|
providedDb?: ReturnType<typeof database>
|
|
) {
|
|
const db = providedDb || database();
|
|
|
|
const standings = await getQPStandings(sportsSeasonId, db);
|
|
|
|
// Group participants by QP total to handle ties
|
|
const groupedByPoints = new Map<string, typeof standings>();
|
|
for (const standing of standings) {
|
|
const points = standing.totalQualifyingPoints;
|
|
if (!groupedByPoints.has(points)) {
|
|
groupedByPoints.set(points, []);
|
|
}
|
|
groupedByPoints.get(points)?.push(standing);
|
|
}
|
|
|
|
// Assign rankings, handling ties
|
|
let currentRank = 1;
|
|
const updates = [];
|
|
|
|
// Sort by points descending
|
|
const sortedGroups = Array.from(groupedByPoints.entries()).toSorted((a, b) => {
|
|
return parseFloat(b[0]) - parseFloat(a[0]);
|
|
});
|
|
|
|
for (const [_, group] of sortedGroups) {
|
|
// All participants in this group get the same rank
|
|
for (const standing of group) {
|
|
updates.push({
|
|
id: standing.id,
|
|
finalRanking: currentRank,
|
|
});
|
|
}
|
|
// Increment rank by the size of the group
|
|
currentRank += group.length;
|
|
}
|
|
|
|
// Update all rankings
|
|
for (const update of updates) {
|
|
await db
|
|
.update(schema.seasonParticipantQualifyingTotals)
|
|
.set({ finalRanking: update.finalRanking, updatedAt: new Date() })
|
|
.where(eq(schema.seasonParticipantQualifyingTotals.id, update.id));
|
|
}
|
|
|
|
return updates;
|
|
}
|
|
|
|
/**
|
|
* Reset qualifying points for a sports season (useful for testing or corrections)
|
|
*/
|
|
export async function resetQualifyingPoints(
|
|
sportsSeasonId: string,
|
|
providedDb?: ReturnType<typeof database>
|
|
) {
|
|
const db = providedDb || database();
|
|
|
|
await db
|
|
.delete(schema.seasonParticipantQualifyingTotals)
|
|
.where(eq(schema.seasonParticipantQualifyingTotals.sportsSeasonId, sportsSeasonId));
|
|
}
|