import { BadRequestException, Injectable, NotFoundException, } from '@nestjs/common'; import mongoose from 'mongoose'; import { ConnectionService } from '../global/database/connection.service'; import type { MatchDocument, TournamentCode, TournamentCodeDocument, TournamentCodeState, TournamentSpectatorType, } from '../global/database/schema'; import { DEFAULT_TOURNAMENT_GAME_COUNT, TOURNAMENT_CODE_EXPIRING_SOON_MS, TOURNAMENT_CODE_EXPIRY_MARGIN_MS, TOURNAMENT_CODE_PATTERN, } from './tournament-code.constants'; import type { BulkUploadTournamentCodesResponse, TournamentCodeSlotView, TournamentCodeUploadItem, } from './tournament-code.types'; const DEFAULT_REGION = 'kr'; const DEFAULT_SPECTATOR_TYPE: TournamentSpectatorType = 'ALL'; @Injectable() export class TournamentCodeService { constructor(private readonly connectionService: ConnectionService) {} public async bulkUpload(params: { communityId: mongoose.Types.ObjectId; uploadedBy: mongoose.Types.ObjectId; codes: TournamentCodeUploadItem[]; }): Promise { const TournamentCodeModel = await this.connectionService.getModel('tournamentCode'); const invalid: BulkUploadTournamentCodesResponse['invalid'] = []; const duplicates: string[] = []; const valid: Array< Omit & { uploadedBy: mongoose.Types.ObjectId; } > = []; const seen = new Set(); for (const item of params.codes) { const code = this.normalizeCode(item.code); if (!code) { invalid.push({ code: item.code ?? '', reason: 'empty-code' }); continue; } if (!TOURNAMENT_CODE_PATTERN.test(code)) { invalid.push({ code, reason: 'invalid-format' }); continue; } if (seen.has(code)) { duplicates.push(code); continue; } seen.add(code); const expiresAt = new Date(item.expiresAt); if (Number.isNaN(expiresAt.getTime())) { invalid.push({ code, reason: 'invalid-expiresAt' }); continue; } if (expiresAt <= new Date()) { invalid.push({ code, reason: 'expired-expiresAt' }); continue; } valid.push({ code, region: DEFAULT_REGION, mapType: 'SUMMONERS_RIFT', teamSize: 5, spectatorType: item.spectatorType ?? DEFAULT_SPECTATOR_TYPE, metadata: item.metadata, expiresAt, state: 'available', uploadedBy: params.uploadedBy, uploadedAt: new Date(), source: item.source, notes: item.notes, }); } if (valid.length === 0) { return { inserted: 0, duplicates, invalid }; } const existing = await TournamentCodeModel.find({ code: { $in: valid.map((item) => item.code) }, }) .select({ code: 1 }) .lean() .exec(); const existingCodes = new Set(existing.map((item) => item.code)); duplicates.push(...existing.map((item) => item.code)); const insertable = valid.filter((item) => !existingCodes.has(item.code)); if (insertable.length > 0) { await TournamentCodeModel.insertMany(insertable, { ordered: false }); } await this.attachPendingMatches(params.communityId); return { inserted: insertable.length, duplicates: [...new Set(duplicates)], invalid, }; } public async list(params: { state?: TournamentCodeState; limit?: number; }): Promise { const TournamentCodeModel = await this.connectionService.getModel('tournamentCode'); const filter: { state?: TournamentCodeState } = {}; if (params.state) filter.state = params.state; return TournamentCodeModel.find(filter) .sort({ expiresAt: 1, uploadedAt: -1 }) .limit(Math.min(params.limit ?? 100, 300)) .exec(); } public async stats(): Promise<{ byState: Record; expiringSoon: number; available: number; }> { const TournamentCodeModel = await this.connectionService.getModel('tournamentCode'); const states: TournamentCodeState[] = [ 'available', 'reserved', 'used', 'expired', 'released', ]; const counts = await TournamentCodeModel.aggregate<{ _id: TournamentCodeState; count: number; }>([{ $group: { _id: '$state', count: { $sum: 1 } } }]).exec(); const byState = Object.fromEntries(states.map((state) => [state, 0])) as Record< TournamentCodeState, number >; for (const entry of counts) byState[entry._id] = entry.count; const expiringSoon = await TournamentCodeModel.countDocuments({ state: 'available', expiresAt: { $gt: new Date(), $lte: new Date(Date.now() + TOURNAMENT_CODE_EXPIRING_SOON_MS), }, }); return { byState, expiringSoon, available: byState.available }; } public async discardAvailable(id: mongoose.Types.ObjectId): Promise { const TournamentCodeModel = await this.connectionService.getModel('tournamentCode'); const result = await TournamentCodeModel.deleteOne({ _id: id, state: 'available', }).exec(); if (result.deletedCount === 0) { throw new BadRequestException('Only available tournament codes can be deleted.'); } } public async restoreToAvailable( id: mongoose.Types.ObjectId, ): Promise { const TournamentCodeModel = await this.connectionService.getModel('tournamentCode'); const MatchModel = await this.connectionService.getModel('match'); const code = await TournamentCodeModel.findById(id); if (!code) throw new NotFoundException('Tournament code not found.'); if (code.state !== 'released' && code.state !== 'reserved') { throw new BadRequestException( 'Only released or reserved tournament codes can be restored.', ); } const previousMatchId = code.matchId; code.state = 'available'; code.matchId = undefined; code.gameNumber = undefined; code.reservedAt = undefined; code.releasedAt = undefined; await code.save(); if (previousMatchId) { await MatchModel.updateOne( { _id: previousMatchId }, { $pull: { tournamentCodeIds: code._id } }, ).exec(); await this.attachPendingMatches(); } return code; } public async reserveForMatch( matchOrId: MatchDocument | mongoose.Types.ObjectId, ): Promise { const MatchModel = await this.connectionService.getModel('match'); const TournamentCodeModel = await this.connectionService.getModel('tournamentCode'); const match = matchOrId instanceof mongoose.Types.ObjectId ? await MatchModel.findById(matchOrId) : await MatchModel.findById(matchOrId._id); if (!match) throw new NotFoundException('Match not found.'); match.gameCount = match.gameCount || DEFAULT_TOURNAMENT_GAME_COUNT; const need = match.gameCount - match.tournamentCodeIds.length; if (need <= 0) return match; const reservedIds: mongoose.Types.ObjectId[] = []; const startGameNumber = match.tournamentCodeIds.length + 1; const expiresAfter = new Date(Date.now() + TOURNAMENT_CODE_EXPIRY_MARGIN_MS); for (let index = 0; index < need; index += 1) { const code = await TournamentCodeModel.findOneAndUpdate( { state: 'available', region: DEFAULT_REGION, mapType: 'SUMMONERS_RIFT', teamSize: 5, expiresAt: { $gt: expiresAfter }, }, { $set: { state: 'reserved', matchId: match._id, gameNumber: startGameNumber + index, reservedAt: new Date(), }, $unset: { releasedAt: 1 }, }, { sort: { expiresAt: 1 }, returnDocument: 'after' }, ).exec(); if (!code) break; reservedIds.push(code._id); } if (reservedIds.length > 0) { match.tournamentCodeIds.push(...reservedIds); await match.save(); } return match; } public async releaseFromMatch( matchOrId: MatchDocument | mongoose.Types.ObjectId, ): Promise { const MatchModel = await this.connectionService.getModel('match'); const TournamentCodeModel = await this.connectionService.getModel('tournamentCode'); const match = matchOrId instanceof mongoose.Types.ObjectId ? await MatchModel.findById(matchOrId) : await MatchModel.findById(matchOrId._id); if (!match) return; if (match.tournamentCodeIds.length === 0) return; await TournamentCodeModel.updateMany( { _id: { $in: match.tournamentCodeIds }, state: 'reserved' }, { $set: { state: 'released', releasedAt: new Date() }, $unset: { matchId: 1, gameNumber: 1, reservedAt: 1 }, }, ).exec(); match.tournamentCodeIds = []; await match.save(); } public async markExpired(): Promise { const TournamentCodeModel = await this.connectionService.getModel('tournamentCode'); const result = await TournamentCodeModel.updateMany( { state: { $in: ['available', 'reserved', 'released'] }, expiresAt: { $lte: new Date() }, }, { $set: { state: 'expired' } }, ).exec(); return result.modifiedCount; } public async attachPendingMatches( communityId?: mongoose.Types.ObjectId, ): Promise { const MatchModel = await this.connectionService.getModel('match'); const filter: { status: { $in: string[] }; communityId?: mongoose.Types.ObjectId; } = { status: { $in: ['team-built', 'in-progress'] }, }; if (communityId) filter.communityId = communityId; const matches = await MatchModel.find(filter).exec(); let touched = 0; for (const match of matches) { if ((match.tournamentCodeIds?.length ?? 0) >= (match.gameCount || 0)) { continue; } const before = match.tournamentCodeIds?.length ?? 0; await this.reserveForMatch(match); const after = match.tournamentCodeIds?.length ?? 0; if (after > before) touched += 1; } return touched; } public async buildSlots(match: MatchDocument): Promise { const TournamentCodeModel = await this.connectionService.getModel('tournamentCode'); const gameCount = match.gameCount || DEFAULT_TOURNAMENT_GAME_COUNT; const ids = match.tournamentCodeIds ?? []; const codes = ids.length > 0 ? await TournamentCodeModel.find({ _id: { $in: ids } }).exec() : []; const byGameNumber = new Map( codes .filter((code) => typeof code.gameNumber === 'number') .map((code) => [code.gameNumber as number, code]), ); return Array.from({ length: gameCount }, (_, index) => { const gameNumber = index + 1; const code = byGameNumber.get(gameNumber); if (!code) { return { gameNumber, code: null, expiresAt: null, state: 'pending', riotMatchId: null, }; } return { gameNumber, code: code.code, expiresAt: code.expiresAt.toISOString(), state: code.state, riotMatchId: code.riotMatchId ?? null, }; }); } private normalizeCode(code: string | undefined): string { return (code ?? '').trim().toUpperCase(); } }