fix: close competition cutover integrity gaps

This commit is contained in:
dahyeon committed 2026-07-12 21:22:22 +00:00
1 parent 7ea2002975
commit 683d602d63
57 files changed
+4805 -1582

No files matched your search

+29 -155
View File
@@ -1,14 +1,11 @@
import {
BadRequestException,
ConflictException,
Injectable,
InternalServerErrorException,
NotFoundException,
} from '@nestjs/common';
import mongoose from 'mongoose';
import {
reshuffleDoubleEliminationSeeds,
swapDoubleEliminationSeeds,
} from '../double-elimination/double-elimination.util';
import { MatchStatsService } from '../community-stats/match-stats.service';
import { CommunityStatsService } from '../community-stats/community-stats.service';
import { ConnectionService } from '../global/database/connection.service';
@@ -76,6 +73,7 @@ interface MatchListFilter {
interface JoinMatchParams {
matchId: mongoose.Types.ObjectId;
communityId?: mongoose.Types.ObjectId;
userId: mongoose.Types.ObjectId;
preferredPositions?: PositionPreference[];
// 특정 RiotAccount(puuid)로 참가하고 싶을 때 지정. 없으면 primary 사용.
@@ -101,17 +99,6 @@ interface UpdateParticipantPositionsParams {
subPosition: Position;
}
interface DoubleEliminationAdminParams {
matchId: mongoose.Types.ObjectId;
communityId: mongoose.Types.ObjectId;
actorUserId: mongoose.Types.ObjectId;
}
interface SwapDoubleEliminationSeedsParams extends DoubleEliminationAdminParams {
leftSeedNumber: number;
rightSeedNumber: number;
}
@Injectable()
export class MatchService {
constructor(
@@ -197,9 +184,10 @@ export class MatchService {
public async getById(
matchId: mongoose.Types.ObjectId,
communityId: mongoose.Types.ObjectId,
): Promise<MatchDocument> {
const MatchModel = await this.connectionService.getModel('match');
const match = await MatchModel.findById(matchId);
const match = await MatchModel.findOne({ _id: matchId, communityId });
if (!match) throw new NotFoundException('Match not found.');
return match;
}
@@ -224,15 +212,24 @@ export class MatchService {
throw new BadRequestException('Match does not belong to this community.');
}
const previousStatus = match.status;
if (
previousStatus !== 'recruiting' &&
params.patch.status === 'recruiting'
) {
throw new ConflictException(
'A finalized team build cannot return to recruiting. Preserve its immutable lifecycle and create a new Match instead.',
);
}
if (
previousStatus !== 'recruiting' &&
('maxParticipants' in params.patch ||
'gameCount' in params.patch ||
'gameMode' in params.patch ||
'roundRobinMaxRounds' in params.patch ||
'doubleEliminationResetFinalEnabled' in params.patch)
) {
throw new BadRequestException(
'maxParticipants, gameMode, roundRobinMaxRounds, and doubleEliminationResetFinalEnabled can only be changed while recruiting.',
'maxParticipants, gameCount, gameMode, roundRobinMaxRounds, and doubleEliminationResetFinalEnabled can only be changed while recruiting.',
);
}
const patchToSet =
@@ -252,21 +249,8 @@ export class MatchService {
})
: this.stripMatchConfigInput(params.patch);
match.set(patchToSet);
if (previousStatus !== 'recruiting' && match.status === 'recruiting') {
if (match.tournamentCodeIds.length > 0) {
await this.tournamentCodeService.releaseFromMatch(match);
}
match.tournamentCodeIds = [];
match.gameSchedule = [];
match.teamBuiltAt = undefined;
match.result = undefined;
match.resultPollState = undefined;
}
await match.save();
if (previousStatus !== 'recruiting' && match.status === 'recruiting') {
await this.matchStatsService.removeByMatch(match._id);
await this.communityStatsService.invalidateCommunity(params.communityId);
} else if (match.result?.games?.length) {
if (match.result?.games?.length) {
await this.matchStatsService.buildAndUpsert(match._id);
await this.communityStatsService.invalidateCommunity(params.communityId);
}
@@ -283,62 +267,31 @@ export class MatchService {
if (!match.communityId.equals(params.communityId)) {
throw new BadRequestException('Match does not belong to this community.');
}
if (match.status !== 'recruiting') {
throw new ConflictException(
'Only a recruiting Match can be hard-deleted. Finalized Match history must be preserved.',
);
}
if (match.competitionId) {
throw new ConflictException(
'A Match with a Competition cannot be hard-deleted. Preserve the immutable ledger and archive the Match instead.',
);
}
await this.tournamentCodeService.releaseFromMatch(match);
await this.matchStatsService.removeByMatch(match._id);
await match.deleteOne();
await this.communityStatsService.invalidateCommunity(params.communityId);
}
public async reshuffleDoubleEliminationSeeds(
params: DoubleEliminationAdminParams,
): Promise<MatchDocument> {
const match = await this.loadDoubleEliminationMatch(params);
await this.assertDoubleEliminationSeedsCanChange(match);
await this.releaseReservedDoubleEliminationCodes(match);
match.doubleElimination = reshuffleDoubleEliminationSeeds(
match.doubleElimination as NonNullable<Match['doubleElimination']>,
);
match.doubleElimination.events.push({
type: 'seeds-reshuffled',
actorUserId: params.actorUserId,
createdAt: new Date(),
});
match.markModified('doubleElimination');
await match.save();
await this.tournamentCodeService.reserveForMatch(match);
return match;
}
public async swapDoubleEliminationSeeds(
params: SwapDoubleEliminationSeedsParams,
): Promise<MatchDocument> {
const match = await this.loadDoubleEliminationMatch(params);
await this.assertDoubleEliminationSeedsCanChange(match);
await this.releaseReservedDoubleEliminationCodes(match);
match.doubleElimination = swapDoubleEliminationSeeds(
match.doubleElimination as NonNullable<Match['doubleElimination']>,
{
leftSeedNumber: params.leftSeedNumber,
rightSeedNumber: params.rightSeedNumber,
},
);
match.doubleElimination.events.push({
type: 'seeds-swapped',
actorUserId: params.actorUserId,
createdAt: new Date(),
});
match.markModified('doubleElimination');
await match.save();
await this.tournamentCodeService.reserveForMatch(match);
return match;
}
public async join(params: JoinMatchParams): Promise<MatchDocument> {
const MatchModel = await this.connectionService.getModel('match');
const UserModel = await this.connectionService.getModel('user');
const user = await UserModel.findById(params.userId);
if (!user) throw new NotFoundException('User not found.');
if (params.communityId && !user.communityId.equals(params.communityId)) {
throw new NotFoundException('Match not found.');
}
const selectedRiot = params.riotPuuid
? user.riotAccounts.find((a) => a.puuid === params.riotPuuid)
@@ -362,7 +315,7 @@ export class MatchService {
const updatedMatch = await MatchModel.findOneAndUpdate(
{
_id: params.matchId,
communityId: user.communityId,
communityId: params.communityId ?? user.communityId,
status: 'recruiting',
'participants.userId': { $ne: user._id },
$expr: { $lt: [{ $size: '$participants' }, '$maxParticipants'] },
@@ -438,85 +391,6 @@ export class MatchService {
return gameCount % 2 === 0 ? gameCount + 1 : gameCount;
}
private async loadDoubleEliminationMatch(params: {
matchId: mongoose.Types.ObjectId;
communityId: mongoose.Types.ObjectId;
}): Promise<MatchDocument> {
const MatchModel = await this.connectionService.getModel('match');
let match = await MatchModel.findById(params.matchId);
if (!match) throw new NotFoundException('Match not found.');
if (!match.communityId.equals(params.communityId)) {
throw new BadRequestException('Match does not belong to this community.');
}
if ((match.gameMode ?? 'pair') !== 'double-elimination') {
throw new BadRequestException('Match is not double elimination.');
}
if (!match.doubleElimination?.bracketMatches?.length) {
match = await this.tournamentCodeService.reserveForMatch(match);
}
if (!match.doubleElimination?.bracketMatches?.length) {
throw new BadRequestException('Double elimination bracket is not ready.');
}
return match;
}
private async assertDoubleEliminationSeedsCanChange(
match: MatchDocument,
): Promise<void> {
if (
match.doubleElimination?.bracketMatches.some(
(bracketMatch) => bracketMatch.state === 'completed',
)
) {
throw new BadRequestException(
'Seeds cannot be changed after a bracket match is completed.',
);
}
const TournamentCodeModel =
await this.connectionService.getModel('tournamentCode');
const usedCode = await TournamentCodeModel.exists({
_id: { $in: match.tournamentCodeIds ?? [] },
$or: [{ state: 'used' }, { riotMatchId: { $exists: true } }],
});
if (usedCode) {
throw new BadRequestException(
'Seeds cannot be changed after a tournament code is used.',
);
}
}
private async releaseReservedDoubleEliminationCodes(
match: MatchDocument,
): Promise<void> {
const ids = match.tournamentCodeIds ?? [];
if (ids.length === 0) return;
const TournamentCodeModel =
await this.connectionService.getModel('tournamentCode');
const codes = await TournamentCodeModel.find({
_id: { $in: ids },
matchId: match._id,
state: 'reserved',
bracketMatchId: { $exists: true },
}).exec();
if (codes.length === 0) return;
const releasedIds = codes.map((code) => code._id.toString());
await TournamentCodeModel.updateMany(
{ _id: { $in: codes.map((code) => code._id) } },
{
$set: { state: 'released', releasedAt: new Date() },
$unset: {
matchId: 1,
gameNumber: 1,
bracketMatchId: 1,
reservedAt: 1,
},
},
).exec();
match.tournamentCodeIds = ids.filter(
(id) => !releasedIds.includes(id.toString()),
);
}
public async cancelJoin(
params: CancelMatchJoinParams,
): Promise<MatchDocument> {