Files
lolympus-tournament-support/apps/api/src/modules/match/match.service.ts
T

715 lines
23 KiB
TypeScript

import {
BadRequestException,
ConflictException,
Injectable,
InternalServerErrorException,
NotFoundException,
} from '@nestjs/common';
import mongoose from 'mongoose';
import { MatchStatsService } from '../community-stats/match-stats.service';
import { CommunityStatsService } from '../community-stats/community-stats.service';
import { ConnectionService } from '../global/database/connection.service';
import {
Match,
MatchDocument,
MatchStatus,
POSITIONS,
Position,
PositionPreference,
TierInfo,
} from '../global/database/schema';
import { DEFAULT_TOURNAMENT_GAME_COUNT } from '../tournament-code/tournament-code.constants';
import { TournamentCodeService } from '../tournament-code/tournament-code.service';
import { presentPublicMatch } from './match-public.presenter';
const MATCH_SHORT_CODE_ALPHABET = 'ABCDEFGHJKLMNPQRSTUVWXYZ23456789';
const MATCH_SHORT_CODE_LENGTH = 4;
const MATCH_SHORT_CODE_GENERATION_ATTEMPTS = 20;
const DEFAULT_MATCH_LIST_LIMIT = 50;
const MAX_MATCH_LIST_LIMIT = 200;
const DOUBLE_ELIMINATION_PARTICIPANT_COUNTS = [20, 40] as const;
const DEFAULT_DOUBLE_ELIMINATION_SERIES_GAME_COUNT = 3;
interface DoubleEliminationConfigInput {
doubleEliminationResetFinalEnabled?: boolean;
}
interface CreateMatchParams {
communityId: mongoose.Types.ObjectId;
hostUserId?: mongoose.Types.ObjectId;
data: Partial<Match> &
Pick<Match, 'title' | 'scheduledAt'> &
DoubleEliminationConfigInput;
}
interface UpdateMatchParams {
matchId: mongoose.Types.ObjectId;
communityId: mongoose.Types.ObjectId;
patch: Partial<Match> & DoubleEliminationConfigInput;
}
interface ListMatchesQuery {
communityId: mongoose.Types.ObjectId;
status?: MatchStatus;
limit?: number;
scheduledFrom?: Date;
scheduledTo?: Date;
sort?: 'asc' | 'desc';
}
interface ListMatchesPageQuery extends ListMatchesQuery {
page?: number;
offset?: number;
}
interface MatchListFilter {
communityId: mongoose.Types.ObjectId;
status?: MatchStatus;
scheduledAt?: {
$gte?: Date;
$lt?: Date;
};
}
interface JoinMatchParams {
matchId: mongoose.Types.ObjectId;
communityId?: mongoose.Types.ObjectId;
userId: mongoose.Types.ObjectId;
preferredPositions?: PositionPreference[];
// 특정 RiotAccount(puuid)로 참가하고 싶을 때 지정. 없으면 primary 사용.
riotPuuid?: string;
}
interface CancelMatchJoinParams {
matchId: mongoose.Types.ObjectId;
userId: mongoose.Types.ObjectId;
}
interface RemoveParticipantParams {
matchId: mongoose.Types.ObjectId;
communityId: mongoose.Types.ObjectId;
targetUserId: mongoose.Types.ObjectId;
}
interface UpdateParticipantPositionsParams {
matchId: mongoose.Types.ObjectId;
communityId: mongoose.Types.ObjectId;
targetUserId: mongoose.Types.ObjectId;
mainPosition: Position;
subPosition: Position;
}
@Injectable()
export class MatchService {
constructor(
private readonly connectionService: ConnectionService,
private readonly tournamentCodeService: TournamentCodeService,
private readonly communityStatsService: CommunityStatsService,
private readonly matchStatsService: MatchStatsService,
) {}
public async create(params: CreateMatchParams): Promise<MatchDocument> {
const MatchModel = await this.connectionService.getModel('match');
const CommunityModel = await this.connectionService.getModel('community');
const community = await CommunityModel.findById(params.communityId)
.select({ matchGameCount: 1 })
.lean()
.exec();
const normalizedData = this.normalizeMatchConfig({
...params.data,
gameCount:
params.data.gameCount ??
community?.matchGameCount ??
DEFAULT_TOURNAMENT_GAME_COUNT,
});
return MatchModel.create({
...normalizedData,
shortCode:
normalizedData.shortCode ??
(await this.generateUniqueShortCode(MatchModel, params.communityId)),
communityId: params.communityId,
hostUserId: params.hostUserId,
});
}
public async list(query: ListMatchesQuery): Promise<MatchDocument[]> {
const MatchModel = await this.connectionService.getModel('match');
const filter = this.buildListFilter(query);
return MatchModel.find(filter)
.sort(this.buildListSort(query.sort))
.limit(this.normalizeListLimit(query.limit))
.exec();
}
public async listPage(query: ListMatchesPageQuery): Promise<{
matches: MatchDocument[];
total: number;
page: number;
limit: number;
}> {
const MatchModel = await this.connectionService.getModel('match');
const filter = this.buildListFilter(query);
const page = this.normalizeListPage(query.page);
const limit = this.normalizeListLimit(query.limit);
const offset = this.normalizeListOffset(query.offset);
const skip = offset + (page - 1) * limit;
const [matches, rawTotal] = await Promise.all([
MatchModel.find(filter)
.sort(this.buildListSort(query.sort))
.skip(skip)
.limit(limit)
.exec(),
MatchModel.countDocuments(filter).exec(),
]);
return {
matches,
total: Math.max(rawTotal - offset, 0),
page,
limit,
};
}
public async ensureShortCode(match: MatchDocument): Promise<MatchDocument> {
if (match.shortCode) return match;
const MatchModel = await this.connectionService.getModel('match');
match.shortCode = await this.generateUniqueShortCode(
MatchModel,
match.communityId,
);
await match.save();
return match;
}
public async getById(
matchId: mongoose.Types.ObjectId,
communityId: mongoose.Types.ObjectId,
): Promise<MatchDocument> {
const MatchModel = await this.connectionService.getModel('match');
const match = await MatchModel.findOne({ _id: matchId, communityId });
if (!match) throw new NotFoundException('Match not found.');
return match;
}
public serialize(match: MatchDocument, options: { joined?: boolean } = {}) {
const obj = match.toObject();
return presentPublicMatch(
{
...obj,
gameCount: match.gameCount || DEFAULT_TOURNAMENT_GAME_COUNT,
gameMode: match.gameMode ?? 'pair',
} as never,
options,
);
}
public async update(params: UpdateMatchParams): Promise<MatchDocument> {
const MatchModel = await this.connectionService.getModel('match');
const 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.');
}
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, gameCount, gameMode, roundRobinMaxRounds, and doubleEliminationResetFinalEnabled can only be changed while recruiting.',
);
}
const patchToSet =
previousStatus === 'recruiting'
? this.normalizeMatchConfig({
...params.patch,
gameMode: params.patch.gameMode ?? match.gameMode,
maxParticipants:
params.patch.maxParticipants ?? match.maxParticipants,
gameCount: params.patch.gameCount ?? match.gameCount,
roundRobinMaxRounds:
params.patch.roundRobinMaxRounds ?? match.roundRobinMaxRounds,
doubleEliminationResetFinalEnabled:
params.patch.doubleEliminationResetFinalEnabled ??
params.patch.doubleElimination?.resetFinalEnabled ??
match.doubleElimination?.resetFinalEnabled,
})
: this.stripMatchConfigInput(params.patch);
match.set(patchToSet);
await match.save();
if (match.result?.games?.length) {
await this.matchStatsService.buildAndUpsert(match._id);
await this.communityStatsService.invalidateCommunity(params.communityId);
}
return match;
}
public async remove(params: {
matchId: mongoose.Types.ObjectId;
communityId: mongoose.Types.ObjectId;
}): Promise<void> {
const MatchModel = await this.connectionService.getModel('match');
const 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.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 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)
: user.riotAccounts.find((a) => a.isPrimary);
const selectedTier = this.selectParticipantTier(selectedRiot?.tiers ?? []);
const participant = {
userId: user._id,
puuid: selectedRiot?.puuid,
gameName: selectedRiot?.gameName,
tagLine: selectedRiot?.tagLine,
profileIconId: selectedRiot?.profileIconId,
tier: selectedTier,
preferredPositions: this.resolveJoinPreferredPositions(
params.preferredPositions,
user.preferredPositions,
),
joinedAt: new Date(),
excluded: false,
};
const updatedMatch = await MatchModel.findOneAndUpdate(
{
_id: params.matchId,
communityId: params.communityId ?? user.communityId,
status: 'recruiting',
'participants.userId': { $ne: user._id },
$expr: { $lt: [{ $size: '$participants' }, '$maxParticipants'] },
},
{ $push: { participants: participant } },
{ returnDocument: 'after', runValidators: true },
);
if (updatedMatch) return updatedMatch;
return await this.throwJoinFailure(MatchModel, params.matchId, user);
}
private normalizeMatchConfig<
T extends Partial<Match> & DoubleEliminationConfigInput,
>(input: T): Partial<Match> {
const patch = this.stripMatchConfigInput(input);
const gameMode = patch.gameMode ?? 'pair';
const maxParticipants = patch.maxParticipants ?? 10;
if (gameMode === 'double-elimination') {
if (
!DOUBLE_ELIMINATION_PARTICIPANT_COUNTS.includes(
maxParticipants as (typeof DOUBLE_ELIMINATION_PARTICIPANT_COUNTS)[number],
)
) {
throw new BadRequestException(
'Double elimination supports only 20 or 40 participants.',
);
}
return {
...patch,
gameMode,
maxParticipants,
gameCount: this.normalizeDoubleEliminationSeriesGameCount(
patch.gameCount ?? DEFAULT_DOUBLE_ELIMINATION_SERIES_GAME_COUNT,
),
roundRobinMaxRounds: undefined,
gameSchedule: [],
doubleElimination: {
teamCount: (maxParticipants / 5) as 4 | 8,
resetFinalEnabled:
input.doubleEliminationResetFinalEnabled ??
input.doubleElimination?.resetFinalEnabled ??
false,
resetFinalCreated: false,
seeds: [],
bracketMatches: [],
placements: {},
events: [],
},
};
}
return {
...patch,
gameMode,
doubleElimination: undefined,
};
}
private stripMatchConfigInput<
T extends Partial<Match> & DoubleEliminationConfigInput,
>(input: T): Partial<Match> {
const patch = { ...input };
delete patch.doubleEliminationResetFinalEnabled;
return patch;
}
private normalizeDoubleEliminationSeriesGameCount(gameCount: number): number {
if (!Number.isInteger(gameCount) || gameCount < 1) {
return DEFAULT_DOUBLE_ELIMINATION_SERIES_GAME_COUNT;
}
return gameCount % 2 === 0 ? gameCount + 1 : gameCount;
}
public async cancelJoin(
params: CancelMatchJoinParams,
): 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.');
const updatedMatch = await MatchModel.findOneAndUpdate(
{
_id: params.matchId,
communityId: user.communityId,
status: 'recruiting',
'participants.userId': user._id,
},
{ $pull: { participants: { userId: user._id } } },
{ returnDocument: 'after', runValidators: true },
);
if (updatedMatch) return updatedMatch;
return await this.throwCancelJoinFailure(MatchModel, params.matchId, user);
}
// 관리자 전용 — 특정 참가자를 강제로 제외한다.
public async removeParticipant(
params: RemoveParticipantParams,
): Promise<MatchDocument> {
const MatchModel = await this.connectionService.getModel('match');
const updatedMatch = await MatchModel.findOneAndUpdate(
{
_id: params.matchId,
communityId: params.communityId,
status: 'recruiting',
'participants.userId': params.targetUserId,
},
{ $pull: { participants: { userId: params.targetUserId } } },
{ returnDocument: 'after', runValidators: true },
);
if (updatedMatch) return updatedMatch;
const match = await this.loadRecruitingMatch(
params.matchId,
params.communityId,
);
if (
!match.participants.some((participant) =>
this.sameObjectId(participant.userId, params.targetUserId),
)
) {
throw new NotFoundException('Participant not found.');
}
throw new BadRequestException('Participant could not be removed.');
}
// 관리자 전용 — 참가자의 주/부 포지션(선호 우선순위 1·2)을 교체한다.
public async updateParticipantPositions(
params: UpdateParticipantPositionsParams,
): Promise<MatchDocument> {
const MatchModel = await this.connectionService.getModel('match');
const match = await this.loadRecruitingMatch(
params.matchId,
params.communityId,
);
const participant = match.participants.find((entry) =>
entry.userId.equals(params.targetUserId),
);
if (!participant) {
throw new NotFoundException('Participant not found.');
}
const preferredPositions = this.reorderPreferredPositions(
params.mainPosition,
params.subPosition,
participant.preferredPositions,
);
const updatedMatch = await MatchModel.findOneAndUpdate(
{
_id: params.matchId,
communityId: params.communityId,
status: 'recruiting',
'participants.userId': params.targetUserId,
},
{
$set: {
'participants.$[participant].preferredPositions': preferredPositions,
},
},
{
arrayFilters: [{ 'participant.userId': params.targetUserId }],
returnDocument: 'after',
runValidators: true,
},
);
if (!updatedMatch) {
throw new BadRequestException(
'Participant positions could not be updated.',
);
}
return updatedMatch;
}
private async loadRecruitingMatch(
matchId: mongoose.Types.ObjectId,
communityId: mongoose.Types.ObjectId,
): Promise<MatchDocument> {
const MatchModel = await this.connectionService.getModel('match');
const match = await MatchModel.findById(matchId);
if (!match) throw new NotFoundException('Match not found.');
if (!match.communityId.equals(communityId)) {
throw new BadRequestException('Different community.');
}
if (match.status !== 'recruiting') {
throw new BadRequestException('Match is not recruiting.');
}
return match;
}
private async throwJoinFailure(
MatchModel: mongoose.Model<Match>,
matchId: mongoose.Types.ObjectId,
user: {
_id: mongoose.Types.ObjectId;
communityId: mongoose.Types.ObjectId;
},
): Promise<never> {
const match = await MatchModel.findById(matchId);
if (!match) throw new NotFoundException('Match not found.');
if (!this.sameObjectId(match.communityId, user.communityId)) {
throw new BadRequestException(
'User and match belong to different communities.',
);
}
if (match.status !== 'recruiting') {
throw new BadRequestException('Match is not recruiting.');
}
if (
match.participants.some((participant) =>
this.sameObjectId(participant.userId, user._id),
)
) {
throw new BadRequestException('User already joined this match.');
}
if (match.participants.length >= match.maxParticipants) {
throw new BadRequestException('Match is full.');
}
throw new BadRequestException('Unable to join this match.');
}
private async throwCancelJoinFailure(
MatchModel: mongoose.Model<Match>,
matchId: mongoose.Types.ObjectId,
user: {
_id: mongoose.Types.ObjectId;
communityId: mongoose.Types.ObjectId;
},
): Promise<never> {
const match = await MatchModel.findById(matchId);
if (!match) throw new NotFoundException('Match not found.');
if (!this.sameObjectId(match.communityId, user.communityId)) {
throw new BadRequestException(
'User and match belong to different communities.',
);
}
if (match.status !== 'recruiting') {
throw new BadRequestException('Match is not recruiting.');
}
if (
!match.participants.some((participant) =>
this.sameObjectId(participant.userId, user._id),
)
) {
throw new BadRequestException('User has not joined this match.');
}
throw new BadRequestException('Unable to cancel match join.');
}
private sameObjectId(
left: mongoose.Types.ObjectId | { toString(): string },
right: mongoose.Types.ObjectId | { toString(): string },
): boolean {
if (left instanceof mongoose.Types.ObjectId) {
return left.equals(right.toString());
}
return left.toString() === right.toString();
}
// 주/부 포지션을 priority 1·2로 올리고 기존 나머지 선호는 뒤로 보존한다.
private reorderPreferredPositions(
mainPosition: Position,
subPosition: Position,
current: PositionPreference[],
): PositionPreference[] {
const ordered: Position[] = [mainPosition];
if (subPosition !== mainPosition) ordered.push(subPosition);
for (const preference of [...current].sort(
(left, right) => left.priority - right.priority,
)) {
if (!ordered.includes(preference.position)) {
ordered.push(preference.position);
}
}
return ordered.map((position, index) => ({
position,
priority: index + 1,
}));
}
private selectParticipantTier(tiers: TierInfo[]): TierInfo | undefined {
const tier =
tiers.find((entry) => entry.queueType === 'RANKED_SOLO_5x5') ?? tiers[0];
if (!tier) return undefined;
return {
leagueId: tier.leagueId,
queueType: tier.queueType,
tier: tier.tier,
rank: tier.rank,
puuid: tier.puuid,
leaguePoints: tier.leaguePoints,
wins: tier.wins,
losses: tier.losses,
veteran: tier.veteran,
inactive: tier.inactive,
freshBlood: tier.freshBlood,
hotStreak: tier.hotStreak,
miniSeries: tier.miniSeries,
fetchedAt: tier.fetchedAt,
};
}
private resolveJoinPreferredPositions(
requested: PositionPreference[] | undefined,
saved: PositionPreference[] | undefined,
): PositionPreference[] {
const source = requested?.length
? requested
: saved?.length
? saved
: POSITIONS.map((position, index) => ({
position,
priority: index + 1,
}));
return [...source]
.sort((left, right) => left.priority - right.priority)
.slice(0, 5)
.map((preference, index) => ({
position: preference.position,
priority: index + 1,
}));
}
private buildListFilter(query: ListMatchesQuery): MatchListFilter {
const filter: MatchListFilter = {
communityId: query.communityId,
};
if (query.status) filter.status = query.status;
if (query.scheduledFrom || query.scheduledTo) {
filter.scheduledAt = {};
if (query.scheduledFrom) filter.scheduledAt.$gte = query.scheduledFrom;
if (query.scheduledTo) filter.scheduledAt.$lt = query.scheduledTo;
}
return filter;
}
private buildListSort(sort?: 'asc' | 'desc'): { scheduledAt: 1 | -1 } {
return { scheduledAt: sort === 'asc' ? 1 : -1 };
}
private normalizeListLimit(limit?: number): number {
if (!Number.isFinite(limit) || !limit || limit < 1) {
return DEFAULT_MATCH_LIST_LIMIT;
}
return Math.min(Math.floor(limit), MAX_MATCH_LIST_LIMIT);
}
private normalizeListPage(page?: number): number {
if (!Number.isFinite(page) || !page || page < 1) {
return 1;
}
return Math.floor(page);
}
private normalizeListOffset(offset?: number): number {
if (!Number.isFinite(offset) || !offset || offset < 1) {
return 0;
}
return Math.floor(offset);
}
private async generateUniqueShortCode(
MatchModel: mongoose.Model<Match>,
communityId: mongoose.Types.ObjectId,
): Promise<string> {
for (
let attempt = 0;
attempt < MATCH_SHORT_CODE_GENERATION_ATTEMPTS;
attempt += 1
) {
const shortCode = this.generateShortCode();
const exists = await MatchModel.exists({ communityId, shortCode });
if (!exists) return shortCode;
}
throw new InternalServerErrorException(
'Failed to generate unique match short code.',
);
}
private generateShortCode(): string {
let code = '';
for (let index = 0; index < MATCH_SHORT_CODE_LENGTH; index += 1) {
const alphabetIndex = Math.floor(
Math.random() * MATCH_SHORT_CODE_ALPHABET.length,
);
code += MATCH_SHORT_CODE_ALPHABET[alphabetIndex];
}
return code;
}
}