feat(api): add tournament code and result collection
This commit is contained in:
1 parent
141651d2d1
commit
9bcff3bb5d
12 files changed
+1382
No files matched your search
@@ -0,0 +1,4 @@
|
||||
export const TOURNAMENT_CODE_PATTERN = /^[A-Z0-9-]{8,}$/i;
|
||||
export const TOURNAMENT_CODE_EXPIRY_MARGIN_MS = 24 * 60 * 60 * 1000;
|
||||
export const TOURNAMENT_CODE_EXPIRING_SOON_MS = 7 * 24 * 60 * 60 * 1000;
|
||||
export const DEFAULT_TOURNAMENT_GAME_COUNT = 3;
|
||||
@@ -0,0 +1,105 @@
|
||||
import {
|
||||
BadRequestException,
|
||||
Body,
|
||||
Controller,
|
||||
Delete,
|
||||
Get,
|
||||
HttpCode,
|
||||
HttpStatus,
|
||||
Param,
|
||||
Post,
|
||||
Query,
|
||||
UseGuards,
|
||||
} from '@nestjs/common';
|
||||
import mongoose from 'mongoose';
|
||||
import { CurrentUser } from '../auth/current-user.decorator';
|
||||
import { Roles } from '../auth/roles.decorator';
|
||||
import { RolesGuard } from '../auth/roles.guard';
|
||||
import { ParseObjectIdPipe } from '../common/parse-object-id.pipe';
|
||||
import type {
|
||||
TournamentCodeState,
|
||||
UserDocument,
|
||||
} from '../global/database/schema';
|
||||
import { TournamentCodeService } from './tournament-code.service';
|
||||
import type { BulkUploadTournamentCodesRequest } from './tournament-code.types';
|
||||
|
||||
@Controller('communities/:communityId/tournament-codes')
|
||||
@Roles('owner', 'admin')
|
||||
@UseGuards(RolesGuard)
|
||||
export class TournamentCodeController {
|
||||
constructor(private readonly tournamentCodeService: TournamentCodeService) {}
|
||||
|
||||
@Post()
|
||||
public async bulkUpload(
|
||||
@CurrentUser() currentUser: UserDocument,
|
||||
@Param('communityId', ParseObjectIdPipe)
|
||||
communityId: mongoose.Types.ObjectId,
|
||||
@Body() body: BulkUploadTournamentCodesRequest,
|
||||
) {
|
||||
this.assertSameCommunity(currentUser, communityId);
|
||||
return this.tournamentCodeService.bulkUpload({
|
||||
communityId,
|
||||
uploadedBy: currentUser._id,
|
||||
codes: body.codes ?? [],
|
||||
});
|
||||
}
|
||||
|
||||
@Get()
|
||||
public async list(
|
||||
@CurrentUser() currentUser: UserDocument,
|
||||
@Param('communityId', ParseObjectIdPipe)
|
||||
communityId: mongoose.Types.ObjectId,
|
||||
@Query('state') state?: TournamentCodeState,
|
||||
@Query('limit') limit?: string,
|
||||
) {
|
||||
this.assertSameCommunity(currentUser, communityId);
|
||||
return {
|
||||
codes: await this.tournamentCodeService.list({
|
||||
state,
|
||||
limit: limit ? Number(limit) : undefined,
|
||||
}),
|
||||
};
|
||||
}
|
||||
|
||||
@Get('stats')
|
||||
public async stats(
|
||||
@CurrentUser() currentUser: UserDocument,
|
||||
@Param('communityId', ParseObjectIdPipe)
|
||||
communityId: mongoose.Types.ObjectId,
|
||||
) {
|
||||
this.assertSameCommunity(currentUser, communityId);
|
||||
return this.tournamentCodeService.stats();
|
||||
}
|
||||
|
||||
@Post(':id/release')
|
||||
public async restore(
|
||||
@CurrentUser() currentUser: UserDocument,
|
||||
@Param('communityId', ParseObjectIdPipe)
|
||||
communityId: mongoose.Types.ObjectId,
|
||||
@Param('id', ParseObjectIdPipe) id: mongoose.Types.ObjectId,
|
||||
) {
|
||||
this.assertSameCommunity(currentUser, communityId);
|
||||
return this.tournamentCodeService.restoreToAvailable(id);
|
||||
}
|
||||
|
||||
@Delete(':id')
|
||||
@HttpCode(HttpStatus.NO_CONTENT)
|
||||
public async discard(
|
||||
@CurrentUser() currentUser: UserDocument,
|
||||
@Param('communityId', ParseObjectIdPipe)
|
||||
communityId: mongoose.Types.ObjectId,
|
||||
@Param('id', ParseObjectIdPipe) id: mongoose.Types.ObjectId,
|
||||
) {
|
||||
this.assertSameCommunity(currentUser, communityId);
|
||||
await this.tournamentCodeService.discardAvailable(id);
|
||||
}
|
||||
|
||||
private assertSameCommunity(
|
||||
user: UserDocument,
|
||||
communityId: mongoose.Types.ObjectId,
|
||||
): void {
|
||||
if (!user.communityId.equals(communityId)) {
|
||||
throw new BadRequestException('Different community.');
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,11 @@
|
||||
import { Module } from '@nestjs/common';
|
||||
import { TournamentCodeController } from './tournament-code.controller';
|
||||
import { TournamentCodeScheduler } from './tournament-code.scheduler';
|
||||
import { TournamentCodeService } from './tournament-code.service';
|
||||
|
||||
@Module({
|
||||
controllers: [TournamentCodeController],
|
||||
providers: [TournamentCodeService, TournamentCodeScheduler],
|
||||
exports: [TournamentCodeService],
|
||||
})
|
||||
export class TournamentCodeModule {}
|
||||
@@ -0,0 +1,57 @@
|
||||
import { Injectable, Logger, OnModuleDestroy, OnModuleInit } from '@nestjs/common';
|
||||
import { TournamentCodeService } from './tournament-code.service';
|
||||
|
||||
@Injectable()
|
||||
export class TournamentCodeScheduler implements OnModuleInit, OnModuleDestroy {
|
||||
private readonly logger = new Logger(TournamentCodeScheduler.name);
|
||||
private attachTimer?: NodeJS.Timeout;
|
||||
private expireTimer?: NodeJS.Timeout;
|
||||
|
||||
constructor(private readonly tournamentCodeService: TournamentCodeService) {}
|
||||
|
||||
public onModuleInit() {
|
||||
this.attachTimer = setInterval(() => {
|
||||
void this.attachPending();
|
||||
}, 30_000);
|
||||
this.expireTimer = setInterval(() => {
|
||||
void this.markExpired();
|
||||
}, 60 * 60 * 1000);
|
||||
this.attachTimer.unref?.();
|
||||
this.expireTimer.unref?.();
|
||||
|
||||
void this.attachPending();
|
||||
void this.markExpired();
|
||||
}
|
||||
|
||||
public onModuleDestroy() {
|
||||
if (this.attachTimer) clearInterval(this.attachTimer);
|
||||
if (this.expireTimer) clearInterval(this.expireTimer);
|
||||
}
|
||||
|
||||
private async attachPending() {
|
||||
try {
|
||||
const touched = await this.tournamentCodeService.attachPendingMatches();
|
||||
if (touched > 0) {
|
||||
this.logger.debug(`Attached tournament codes for ${touched} matches.`);
|
||||
}
|
||||
} catch (error) {
|
||||
this.logger.warn(
|
||||
`Failed to attach pending tournament codes: ${
|
||||
error instanceof Error ? error.message : error
|
||||
}`,
|
||||
);
|
||||
}
|
||||
}
|
||||
|
||||
private async markExpired() {
|
||||
try {
|
||||
await this.tournamentCodeService.markExpired();
|
||||
} catch (error) {
|
||||
this.logger.warn(
|
||||
`Failed to mark expired tournament codes: ${
|
||||
error instanceof Error ? error.message : error
|
||||
}`,
|
||||
);
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,365 @@
|
||||
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<BulkUploadTournamentCodesResponse> {
|
||||
const TournamentCodeModel =
|
||||
await this.connectionService.getModel('tournamentCode');
|
||||
const invalid: BulkUploadTournamentCodesResponse['invalid'] = [];
|
||||
const duplicates: string[] = [];
|
||||
const valid: Array<
|
||||
Omit<TournamentCode, 'createdAt' | 'updatedAt'> & {
|
||||
uploadedBy: mongoose.Types.ObjectId;
|
||||
}
|
||||
> = [];
|
||||
const seen = new Set<string>();
|
||||
|
||||
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<TournamentCodeDocument[]> {
|
||||
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<TournamentCodeState, number>;
|
||||
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<void> {
|
||||
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<TournamentCodeDocument> {
|
||||
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<MatchDocument> {
|
||||
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<void> {
|
||||
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<number> {
|
||||
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<number> {
|
||||
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<TournamentCodeSlotView[]> {
|
||||
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();
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,31 @@
|
||||
import type {
|
||||
TournamentCodeState,
|
||||
TournamentSpectatorType,
|
||||
} from '../global/database/schema';
|
||||
|
||||
export interface TournamentCodeUploadItem {
|
||||
code: string;
|
||||
expiresAt: string;
|
||||
spectatorType?: TournamentSpectatorType;
|
||||
metadata?: Record<string, unknown>;
|
||||
source?: string;
|
||||
notes?: string;
|
||||
}
|
||||
|
||||
export interface BulkUploadTournamentCodesRequest {
|
||||
codes: TournamentCodeUploadItem[];
|
||||
}
|
||||
|
||||
export interface BulkUploadTournamentCodesResponse {
|
||||
inserted: number;
|
||||
duplicates: string[];
|
||||
invalid: Array<{ code: string; reason: string }>;
|
||||
}
|
||||
|
||||
export interface TournamentCodeSlotView {
|
||||
gameNumber: number;
|
||||
code: string | null;
|
||||
expiresAt: string | null;
|
||||
state: TournamentCodeState | 'pending';
|
||||
riotMatchId: string | null;
|
||||
}
|
||||
Reference in new issue
Block a user