683 lines
21 KiB
TypeScript
683 lines
21 KiB
TypeScript
import 'reflect-metadata';
|
|
import { Module } from '@nestjs/common';
|
|
import { ConfigModule } from '@nestjs/config';
|
|
import { NestFactory } from '@nestjs/core';
|
|
import mongoose from 'mongoose';
|
|
import { readFile } from 'node:fs/promises';
|
|
import { resolve } from 'node:path';
|
|
import { ConnectionService, resolveMongoDbName } from '../connection.service';
|
|
import type {
|
|
MatchDocument,
|
|
MatchGameAssignment,
|
|
MatchGameResult,
|
|
MatchSeriesResult,
|
|
TournamentCodeDocument,
|
|
} from '../schema';
|
|
import { SecretModule } from '../../secret/secret.module';
|
|
import { MatchStatsFragmentBuilder } from '../../../community-stats/match-stats-fragment.builder';
|
|
import { MatchStatsRepository } from '../../../community-stats/match-stats.repository';
|
|
import { MatchStatsService } from '../../../community-stats/match-stats.service';
|
|
|
|
interface CliOptions {
|
|
dryRun: boolean;
|
|
matchId: mongoose.Types.ObjectId;
|
|
maxRounds: number;
|
|
nodeEnv: string;
|
|
}
|
|
|
|
interface ResultGamePlan {
|
|
oldGameNumber: number;
|
|
newGameNumber: number;
|
|
roundNumber: number;
|
|
teamAIndex: number;
|
|
teamBIndex: number;
|
|
game: MatchGameResult;
|
|
}
|
|
|
|
interface RepairPlan {
|
|
schedule: MatchGameAssignment[];
|
|
gamePlans: ResultGamePlan[];
|
|
seriesResults: MatchSeriesResult[];
|
|
winnerTeamIndex?: number;
|
|
usedCodeByOldGameNumber: Map<number, TournamentCodeDocument>;
|
|
releasedCodes: TournamentCodeDocument[];
|
|
}
|
|
|
|
@Module({
|
|
imports: [
|
|
ConfigModule.forRoot({
|
|
isGlobal: true,
|
|
envFilePath: [
|
|
resolve(__dirname, '../../../../../../project.env'),
|
|
resolve(process.cwd(), '../project.env'),
|
|
resolve(process.cwd(), 'apps/project.env'),
|
|
resolve(process.cwd(), 'project.env'),
|
|
],
|
|
}),
|
|
SecretModule,
|
|
],
|
|
providers: [
|
|
ConnectionService,
|
|
MatchStatsFragmentBuilder,
|
|
MatchStatsRepository,
|
|
MatchStatsService,
|
|
],
|
|
})
|
|
class RepairModule {}
|
|
|
|
async function loadMachineEnvFile() {
|
|
const homeDir = process.env.HOME ?? process.env.USERPROFILE;
|
|
if (!homeDir) return;
|
|
|
|
const machineEnvFile = resolve(homeDir, 'source/global-env-vars.txt');
|
|
|
|
try {
|
|
const file = await readFile(machineEnvFile, 'utf8');
|
|
for (const rawLine of file.split(/\r?\n/)) {
|
|
const line = rawLine.trim();
|
|
if (!line || line.startsWith('#')) continue;
|
|
|
|
const matched = line.match(/^([A-Za-z_][A-Za-z0-9_]*)\s*=\s*(.*)$/);
|
|
if (!matched) continue;
|
|
|
|
const [, key, rawValue] = matched;
|
|
process.env[key] = rawValue.replace(/^["']|["']$/g, '');
|
|
}
|
|
} catch {
|
|
// 로컬 machine env 파일이 없으면 그냥 지나간다.
|
|
}
|
|
}
|
|
|
|
function parseArgs(argv: string[]): CliOptions {
|
|
let dryRun = true;
|
|
let matchId: mongoose.Types.ObjectId | undefined;
|
|
let maxRounds = 3;
|
|
let nodeEnv = process.env.NODE_ENV ?? 'dev';
|
|
|
|
for (let index = 0; index < argv.length; index += 1) {
|
|
const arg = argv[index];
|
|
if (arg === '--apply') {
|
|
dryRun = false;
|
|
continue;
|
|
}
|
|
if (arg === '--dry-run') {
|
|
dryRun = true;
|
|
continue;
|
|
}
|
|
if (arg === '--match-id') {
|
|
const value = argv[index + 1];
|
|
if (!value || !mongoose.isValidObjectId(value)) {
|
|
throw new Error('--match-id requires a valid ObjectId.');
|
|
}
|
|
matchId = new mongoose.Types.ObjectId(value);
|
|
index += 1;
|
|
continue;
|
|
}
|
|
if (arg.startsWith('--match-id=')) {
|
|
const value = arg.slice('--match-id='.length);
|
|
if (!mongoose.isValidObjectId(value)) {
|
|
throw new Error('--match-id requires a valid ObjectId.');
|
|
}
|
|
matchId = new mongoose.Types.ObjectId(value);
|
|
continue;
|
|
}
|
|
if (arg === '--max-rounds') {
|
|
maxRounds = parsePositiveInteger(argv[index + 1], '--max-rounds');
|
|
index += 1;
|
|
continue;
|
|
}
|
|
if (arg.startsWith('--max-rounds=')) {
|
|
maxRounds = parsePositiveInteger(
|
|
arg.slice('--max-rounds='.length),
|
|
'--max-rounds',
|
|
);
|
|
continue;
|
|
}
|
|
if (arg === '--env') {
|
|
const value = argv[index + 1];
|
|
if (!value) throw new Error('--env requires dev, staging, or prod.');
|
|
nodeEnv = value;
|
|
index += 1;
|
|
continue;
|
|
}
|
|
if (arg.startsWith('--env=')) {
|
|
nodeEnv = arg.slice('--env='.length);
|
|
continue;
|
|
}
|
|
if (arg === '--help' || arg === '-h') {
|
|
printHelp();
|
|
process.exit(0);
|
|
}
|
|
throw new Error(`Unknown argument: ${arg}`);
|
|
}
|
|
|
|
if (!matchId) throw new Error('--match-id is required.');
|
|
if (!['dev', 'staging', 'prod'].includes(nodeEnv)) {
|
|
throw new Error('--env must be dev, staging, or prod.');
|
|
}
|
|
|
|
return { dryRun, matchId, maxRounds, nodeEnv };
|
|
}
|
|
|
|
function parsePositiveInteger(value: string | undefined, label: string) {
|
|
const parsed = Number(value);
|
|
if (!Number.isInteger(parsed) || parsed < 1) {
|
|
throw new Error(`${label} requires a positive integer.`);
|
|
}
|
|
return parsed;
|
|
}
|
|
|
|
function printHelp() {
|
|
console.log(`Usage:
|
|
pnpm --filter api exec ts-node src/modules/global/database/migrations/repair-limited-round-robin-finished-match.ts --match-id <id> --max-rounds 3 --dry-run
|
|
pnpm --filter api exec ts-node src/modules/global/database/migrations/repair-limited-round-robin-finished-match.ts --match-id <id> --max-rounds 3 --env prod --apply
|
|
|
|
Options:
|
|
--match-id <id> Match ObjectId to repair.
|
|
--max-rounds <n> Number of round-robin rounds to keep. Default: 3.
|
|
--dry-run Print the repair plan without writing. Default.
|
|
--apply Apply match, tournament code, and stats updates.
|
|
--env <env> dev | staging | prod. Default: NODE_ENV or dev.
|
|
`);
|
|
}
|
|
|
|
async function main() {
|
|
const options = parseArgs(process.argv.slice(2));
|
|
process.env.NODE_ENV = options.nodeEnv;
|
|
await loadMachineEnvFile();
|
|
|
|
const app = await NestFactory.createApplicationContext(RepairModule, {
|
|
logger: ['log', 'warn', 'error'],
|
|
});
|
|
|
|
try {
|
|
const connectionService = app.get(ConnectionService);
|
|
const matchStatsService = app.get(MatchStatsService);
|
|
const MatchModel = await connectionService.getModel('match');
|
|
const TournamentCodeModel =
|
|
await connectionService.getModel('tournamentCode');
|
|
const match = await MatchModel.findById(options.matchId).exec();
|
|
if (!match) {
|
|
throw new Error(`Match not found: ${options.matchId.toString()}`);
|
|
}
|
|
|
|
const codes = await TournamentCodeModel.find({
|
|
_id: { $in: match.tournamentCodeIds ?? [] },
|
|
})
|
|
.sort({ gameNumber: 1, reservedAt: 1, _id: 1 })
|
|
.exec();
|
|
const plan = buildRepairPlan(match, codes, options.maxRounds);
|
|
|
|
printPlan(options, match, codes, plan);
|
|
|
|
if (options.dryRun) {
|
|
console.log(
|
|
'No writes were made. Re-run with --apply to update MongoDB.',
|
|
);
|
|
return;
|
|
}
|
|
|
|
const now = new Date();
|
|
const session = await (
|
|
await connectionService.getConnection()
|
|
).startSession();
|
|
try {
|
|
await session.withTransaction(async () => {
|
|
await applyTournamentCodeUpdates(plan, now, session);
|
|
await MatchModel.updateOne(
|
|
{ _id: match._id },
|
|
{
|
|
$set: {
|
|
status: 'finished',
|
|
roundRobinMaxRounds: options.maxRounds,
|
|
gameSchedule: plan.schedule,
|
|
tournamentCodeIds: [...plan.usedCodeByOldGameNumber.values()].map(
|
|
(code) => code._id,
|
|
),
|
|
resultPollState: {
|
|
startedAt: match.resultPollState?.startedAt ?? now,
|
|
lastPolledAt: now,
|
|
lastPollOutcome: 'matched',
|
|
matchedCount: plan.gamePlans.length,
|
|
expandedToAllPuuids: true,
|
|
state: 'complete',
|
|
},
|
|
result: {
|
|
winnerTeamIndex: plan.winnerTeamIndex,
|
|
mvpUserId: match.result?.mvpUserId,
|
|
riotMatchIds: plan.gamePlans.map(
|
|
(gamePlan) => gamePlan.game.riotMatchId,
|
|
),
|
|
games: plan.gamePlans.map((gamePlan) => ({
|
|
...toPlainGame(gamePlan.game),
|
|
gameNumber: gamePlan.newGameNumber,
|
|
})),
|
|
seriesResults: plan.seriesResults,
|
|
},
|
|
},
|
|
},
|
|
{ session },
|
|
).exec();
|
|
});
|
|
} finally {
|
|
await session.endSession();
|
|
}
|
|
|
|
await matchStatsService.buildAndUpsert(match._id);
|
|
console.log('Repair applied and match stats rebuilt.');
|
|
} finally {
|
|
await app.close();
|
|
await mongoose.disconnect();
|
|
}
|
|
}
|
|
|
|
function buildRepairPlan(
|
|
match: MatchDocument,
|
|
codes: TournamentCodeDocument[],
|
|
maxRounds: number,
|
|
): RepairPlan {
|
|
if (match.gameMode !== 'round-robin') {
|
|
throw new Error(`Expected round-robin match, got ${match.gameMode}.`);
|
|
}
|
|
|
|
const games = [...(match.result?.games ?? [])]
|
|
.map(toPlainGame)
|
|
.sort((left, right) => left.gameNumber - right.gameNumber);
|
|
if (games.length === 0) {
|
|
throw new Error('Match has no result games to preserve.');
|
|
}
|
|
|
|
const teamIndexes = [...new Set(match.teams.map((team) => team.teamIndex))]
|
|
.filter((teamIndex) => Number.isInteger(teamIndex) && teamIndex > 0)
|
|
.sort((left, right) => left - right);
|
|
if (teamIndexes.length < 2) {
|
|
throw new Error('Match needs at least two teams.');
|
|
}
|
|
if (teamIndexes.length % 2 !== 0) {
|
|
throw new Error('This repair script currently expects an even team count.');
|
|
}
|
|
|
|
const gamesPerRound = teamIndexes.length / 2;
|
|
const requiredGames = gamesPerRound * maxRounds;
|
|
if (games.length !== requiredGames) {
|
|
throw new Error(
|
|
`Expected ${requiredGames} result games for ${maxRounds} rounds and ${teamIndexes.length} teams, got ${games.length}.`,
|
|
);
|
|
}
|
|
|
|
validateResultGames(games, teamIndexes);
|
|
const rounds = partitionIntoRounds(games, teamIndexes, maxRounds);
|
|
const gamePlans = rounds.flatMap((roundGames, roundIndex) =>
|
|
sortRoundGames(roundGames).map((game, gameIndex) => ({
|
|
oldGameNumber: game.gameNumber,
|
|
newGameNumber: roundIndex * gamesPerRound + gameIndex + 1,
|
|
roundNumber: roundIndex + 1,
|
|
teamAIndex: Math.min(game.blueTeamIndex, game.redTeamIndex),
|
|
teamBIndex: Math.max(game.blueTeamIndex, game.redTeamIndex),
|
|
game,
|
|
})),
|
|
);
|
|
|
|
const schedule = gamePlans.map(
|
|
({ newGameNumber, roundNumber, teamAIndex, teamBIndex }) => ({
|
|
gameNumber: newGameNumber,
|
|
roundNumber,
|
|
teamAIndex,
|
|
teamBIndex,
|
|
}),
|
|
);
|
|
|
|
const usedOldGameNumbers = new Set(
|
|
gamePlans.map((gamePlan) => gamePlan.oldGameNumber),
|
|
);
|
|
const usedCodeByOldGameNumber = resolveUsedCodesByOldGameNumber(
|
|
codes,
|
|
gamePlans,
|
|
);
|
|
const releasedCodes = codes.filter(
|
|
(code) => !usedOldGameNumbers.has(code.gameNumber ?? 0),
|
|
);
|
|
const unsafeReleased = releasedCodes.filter((code) => code.state === 'used');
|
|
if (unsafeReleased.length > 0) {
|
|
throw new Error(
|
|
`Refusing to release used tournament codes without matching result games: ${unsafeReleased
|
|
.map((code) => formatCode(code))
|
|
.join(', ')}`,
|
|
);
|
|
}
|
|
|
|
const updatedGames = gamePlans.map((gamePlan) => ({
|
|
...toPlainGame(gamePlan.game),
|
|
gameNumber: gamePlan.newGameNumber,
|
|
}));
|
|
const seriesResults = buildSeriesResults(updatedGames);
|
|
|
|
return {
|
|
schedule,
|
|
gamePlans,
|
|
seriesResults,
|
|
winnerTeamIndex: resolveMatchWinnerTeamIndex(seriesResults),
|
|
usedCodeByOldGameNumber,
|
|
releasedCodes,
|
|
};
|
|
}
|
|
|
|
function validateResultGames(games: MatchGameResult[], teamIndexes: number[]) {
|
|
const validTeamIndexes = new Set(teamIndexes);
|
|
const pairKeys = new Set<string>();
|
|
const gameNumbers = new Set<number>();
|
|
|
|
for (const game of games) {
|
|
if (gameNumbers.has(game.gameNumber)) {
|
|
throw new Error(`Duplicate result gameNumber: ${game.gameNumber}.`);
|
|
}
|
|
gameNumbers.add(game.gameNumber);
|
|
|
|
if (!validTeamIndexes.has(game.blueTeamIndex)) {
|
|
throw new Error(`Invalid blueTeamIndex ${game.blueTeamIndex}.`);
|
|
}
|
|
if (!validTeamIndexes.has(game.redTeamIndex)) {
|
|
throw new Error(`Invalid redTeamIndex ${game.redTeamIndex}.`);
|
|
}
|
|
if (game.blueTeamIndex === game.redTeamIndex) {
|
|
throw new Error(`Game ${game.gameNumber} has the same team twice.`);
|
|
}
|
|
|
|
const key = pairKey(game);
|
|
if (pairKeys.has(key)) {
|
|
throw new Error(`Duplicate team pair in results: ${key}.`);
|
|
}
|
|
pairKeys.add(key);
|
|
}
|
|
}
|
|
|
|
function partitionIntoRounds(
|
|
games: MatchGameResult[],
|
|
teamIndexes: number[],
|
|
maxRounds: number,
|
|
): MatchGameResult[][] {
|
|
const targetPerRound = teamIndexes.length / 2;
|
|
const unused = new Set(games.map((game) => game.gameNumber));
|
|
const byGameNumber = new Map(games.map((game) => [game.gameNumber, game]));
|
|
const rounds: MatchGameResult[][] = [];
|
|
|
|
function fillRound(roundIndex: number): boolean {
|
|
if (roundIndex === maxRounds) return unused.size === 0;
|
|
|
|
const candidates = enumerateRoundCandidates(
|
|
[...unused]
|
|
.map((gameNumber) => byGameNumber.get(gameNumber))
|
|
.filter((game): game is MatchGameResult => Boolean(game)),
|
|
teamIndexes,
|
|
targetPerRound,
|
|
);
|
|
|
|
for (const candidate of candidates) {
|
|
for (const game of candidate) unused.delete(game.gameNumber);
|
|
rounds[roundIndex] = candidate;
|
|
if (fillRound(roundIndex + 1)) return true;
|
|
for (const game of candidate) unused.add(game.gameNumber);
|
|
}
|
|
|
|
rounds.length = roundIndex;
|
|
return false;
|
|
}
|
|
|
|
if (!fillRound(0)) {
|
|
throw new Error(
|
|
'Could not partition result games into simultaneous rounds.',
|
|
);
|
|
}
|
|
|
|
return rounds;
|
|
}
|
|
|
|
function enumerateRoundCandidates(
|
|
availableGames: MatchGameResult[],
|
|
teamIndexes: number[],
|
|
targetPerRound: number,
|
|
): MatchGameResult[][] {
|
|
const candidates: MatchGameResult[][] = [];
|
|
|
|
function visit(usedTeams: Set<number>, chosen: MatchGameResult[]) {
|
|
if (chosen.length === targetPerRound) {
|
|
candidates.push([...chosen]);
|
|
return;
|
|
}
|
|
|
|
const nextTeam = teamIndexes.find((teamIndex) => !usedTeams.has(teamIndex));
|
|
if (!nextTeam) return;
|
|
|
|
const nextGames = availableGames
|
|
.filter((game) => {
|
|
if (!includesTeam(game, nextTeam)) return false;
|
|
return (
|
|
!usedTeams.has(game.blueTeamIndex) &&
|
|
!usedTeams.has(game.redTeamIndex)
|
|
);
|
|
})
|
|
.sort((left, right) => left.gameNumber - right.gameNumber);
|
|
|
|
for (const game of nextGames) {
|
|
chosen.push(game);
|
|
usedTeams.add(game.blueTeamIndex);
|
|
usedTeams.add(game.redTeamIndex);
|
|
visit(usedTeams, chosen);
|
|
usedTeams.delete(game.blueTeamIndex);
|
|
usedTeams.delete(game.redTeamIndex);
|
|
chosen.pop();
|
|
}
|
|
}
|
|
|
|
visit(new Set<number>(), []);
|
|
return candidates;
|
|
}
|
|
|
|
function sortRoundGames(games: MatchGameResult[]) {
|
|
return [...games].sort(
|
|
(left, right) =>
|
|
Math.min(left.blueTeamIndex, left.redTeamIndex) -
|
|
Math.min(right.blueTeamIndex, right.redTeamIndex) ||
|
|
Math.max(left.blueTeamIndex, left.redTeamIndex) -
|
|
Math.max(right.blueTeamIndex, right.redTeamIndex),
|
|
);
|
|
}
|
|
|
|
function resolveUsedCodesByOldGameNumber(
|
|
codes: TournamentCodeDocument[],
|
|
gamePlans: ResultGamePlan[],
|
|
): Map<number, TournamentCodeDocument> {
|
|
const byGameNumber = new Map<number, TournamentCodeDocument[]>();
|
|
for (const code of codes) {
|
|
if (!code.gameNumber) continue;
|
|
const existing = byGameNumber.get(code.gameNumber) ?? [];
|
|
existing.push(code);
|
|
byGameNumber.set(code.gameNumber, existing);
|
|
}
|
|
|
|
const result = new Map<number, TournamentCodeDocument>();
|
|
for (const gamePlan of gamePlans) {
|
|
const candidates = byGameNumber.get(gamePlan.oldGameNumber) ?? [];
|
|
if (candidates.length !== 1) {
|
|
throw new Error(
|
|
`Expected exactly one tournament code for old game ${gamePlan.oldGameNumber}, got ${candidates.length}.`,
|
|
);
|
|
}
|
|
const [code] = candidates;
|
|
if (code.riotMatchId && code.riotMatchId !== gamePlan.game.riotMatchId) {
|
|
throw new Error(
|
|
`Tournament code ${formatCode(code)} has riotMatchId ${code.riotMatchId}, expected ${gamePlan.game.riotMatchId}.`,
|
|
);
|
|
}
|
|
result.set(gamePlan.oldGameNumber, code);
|
|
}
|
|
|
|
return result;
|
|
}
|
|
|
|
async function applyTournamentCodeUpdates(
|
|
plan: RepairPlan,
|
|
now: Date,
|
|
session: mongoose.ClientSession,
|
|
) {
|
|
const usedOperations = plan.gamePlans.map((gamePlan) => {
|
|
const code = plan.usedCodeByOldGameNumber.get(gamePlan.oldGameNumber);
|
|
if (!code) {
|
|
throw new Error(`Missing tournament code for ${gamePlan.oldGameNumber}.`);
|
|
}
|
|
return code.updateOne(
|
|
{
|
|
$set: {
|
|
state: 'used',
|
|
gameNumber: gamePlan.newGameNumber,
|
|
riotMatchId: gamePlan.game.riotMatchId,
|
|
usedAt: resolveGameEndedAt(gamePlan.game),
|
|
},
|
|
$unset: {
|
|
releasedAt: '',
|
|
},
|
|
},
|
|
{ session },
|
|
);
|
|
});
|
|
|
|
const releasedOperations = plan.releasedCodes.map((code) =>
|
|
code.updateOne(
|
|
{
|
|
$set: {
|
|
state: 'released',
|
|
releasedAt: now,
|
|
},
|
|
$unset: {
|
|
matchId: '',
|
|
gameNumber: '',
|
|
reservedAt: '',
|
|
usedAt: '',
|
|
riotMatchId: '',
|
|
},
|
|
},
|
|
{ session },
|
|
),
|
|
);
|
|
|
|
await Promise.all([...usedOperations, ...releasedOperations]);
|
|
}
|
|
|
|
function buildSeriesResults(games: MatchGameResult[]): MatchSeriesResult[] {
|
|
const bySeries = new Map<string, MatchSeriesResult>();
|
|
for (const game of games) {
|
|
const teamAIndex = Math.min(game.blueTeamIndex, game.redTeamIndex);
|
|
const teamBIndex = Math.max(game.blueTeamIndex, game.redTeamIndex);
|
|
const key = `${teamAIndex}:${teamBIndex}`;
|
|
const current =
|
|
bySeries.get(key) ??
|
|
({
|
|
teamAIndex,
|
|
teamBIndex,
|
|
teamAWins: 0,
|
|
teamBWins: 0,
|
|
} satisfies MatchSeriesResult);
|
|
if (game.winnerTeamIndex === teamAIndex) current.teamAWins += 1;
|
|
if (game.winnerTeamIndex === teamBIndex) current.teamBWins += 1;
|
|
current.winnerTeamIndex =
|
|
current.teamAWins > current.teamBWins
|
|
? teamAIndex
|
|
: current.teamBWins > current.teamAWins
|
|
? teamBIndex
|
|
: undefined;
|
|
bySeries.set(key, current);
|
|
}
|
|
return [...bySeries.values()].sort(
|
|
(left, right) =>
|
|
left.teamAIndex - right.teamAIndex || left.teamBIndex - right.teamBIndex,
|
|
);
|
|
}
|
|
|
|
function resolveMatchWinnerTeamIndex(seriesResults: MatchSeriesResult[]) {
|
|
const winsByTeam = new Map<number, number>();
|
|
for (const series of seriesResults) {
|
|
if (!series.winnerTeamIndex) continue;
|
|
winsByTeam.set(
|
|
series.winnerTeamIndex,
|
|
(winsByTeam.get(series.winnerTeamIndex) ?? 0) + 1,
|
|
);
|
|
}
|
|
|
|
const sorted = [...winsByTeam.entries()].sort(
|
|
(left, right) => right[1] - left[1],
|
|
);
|
|
if (sorted.length === 0) return undefined;
|
|
if (sorted.length > 1 && sorted[0][1] === sorted[1][1]) return undefined;
|
|
return sorted[0][0];
|
|
}
|
|
|
|
function printPlan(
|
|
options: CliOptions,
|
|
match: MatchDocument,
|
|
codes: TournamentCodeDocument[],
|
|
plan: RepairPlan,
|
|
) {
|
|
console.log(
|
|
`[limited round-robin repair] mode=${options.dryRun ? 'dry-run' : 'apply'} env=${options.nodeEnv} db=${resolveMongoDbName(options.nodeEnv)}`,
|
|
);
|
|
console.log(
|
|
`[limited round-robin repair] match=${match._id.toString()} title="${match.title}"`,
|
|
);
|
|
console.log(
|
|
`[limited round-robin repair] status ${match.status} -> finished, maxRounds=${options.maxRounds}`,
|
|
);
|
|
console.log(
|
|
`[limited round-robin repair] resultGames=${plan.gamePlans.length} codes kept=${plan.usedCodeByOldGameNumber.size} codes released=${plan.releasedCodes.length} previousCodeIds=${codes.length}`,
|
|
);
|
|
console.log(
|
|
`[limited round-robin repair] winnerTeamIndex=${plan.winnerTeamIndex ?? '(tie)'}`,
|
|
);
|
|
|
|
for (const gamePlan of plan.gamePlans) {
|
|
console.log(
|
|
` R${gamePlan.roundNumber} G${gamePlan.newGameNumber}: ${gamePlan.teamAIndex}팀 vs ${gamePlan.teamBIndex}팀 (old G${gamePlan.oldGameNumber}, riot=${gamePlan.game.riotMatchId})`,
|
|
);
|
|
}
|
|
}
|
|
|
|
function toPlainGame(game: MatchGameResult): MatchGameResult {
|
|
const maybeSubdocument = game as unknown as {
|
|
toObject?: () => MatchGameResult;
|
|
};
|
|
const objectValue =
|
|
typeof maybeSubdocument.toObject === 'function'
|
|
? maybeSubdocument.toObject()
|
|
: game;
|
|
return {
|
|
...objectValue,
|
|
participants: [...(objectValue.participants ?? [])],
|
|
};
|
|
}
|
|
|
|
function includesTeam(game: MatchGameResult, teamIndex: number) {
|
|
return game.blueTeamIndex === teamIndex || game.redTeamIndex === teamIndex;
|
|
}
|
|
|
|
function pairKey(game: MatchGameResult) {
|
|
const teamAIndex = Math.min(game.blueTeamIndex, game.redTeamIndex);
|
|
const teamBIndex = Math.max(game.blueTeamIndex, game.redTeamIndex);
|
|
return `${teamAIndex}:${teamBIndex}`;
|
|
}
|
|
|
|
function resolveGameEndedAt(game: MatchGameResult) {
|
|
return new Date(game.gameCreation + game.gameDuration * 1000);
|
|
}
|
|
|
|
function formatCode(code: TournamentCodeDocument) {
|
|
return `${code._id.toString()}(gameNumber=${code.gameNumber ?? 'none'}, state=${code.state})`;
|
|
}
|
|
|
|
void main()
|
|
.then(() => {
|
|
process.exit(0);
|
|
})
|
|
.catch((error: unknown) => {
|
|
console.error(error instanceof Error ? error.message : error);
|
|
process.exit(1);
|
|
});
|