564 lines
18 KiB
TypeScript
564 lines
18 KiB
TypeScript
import {
|
|
BadRequestException,
|
|
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,
|
|
MatchSeriesResult,
|
|
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';
|
|
|
|
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;
|
|
|
|
interface CreateMatchParams {
|
|
communityId: mongoose.Types.ObjectId;
|
|
hostUserId?: mongoose.Types.ObjectId;
|
|
data: Partial<Match> & Pick<Match, 'title' | 'scheduledAt'>;
|
|
}
|
|
|
|
interface UpdateMatchParams {
|
|
matchId: mongoose.Types.ObjectId;
|
|
communityId: mongoose.Types.ObjectId;
|
|
patch: Partial<Match>;
|
|
}
|
|
|
|
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;
|
|
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();
|
|
return MatchModel.create({
|
|
...params.data,
|
|
shortCode:
|
|
params.data.shortCode ??
|
|
(await this.generateUniqueShortCode(MatchModel, params.communityId)),
|
|
gameCount:
|
|
params.data.gameCount ??
|
|
community?.matchGameCount ??
|
|
DEFAULT_TOURNAMENT_GAME_COUNT,
|
|
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,
|
|
): Promise<MatchDocument> {
|
|
const MatchModel = await this.connectionService.getModel('match');
|
|
const match = await MatchModel.findById(matchId);
|
|
if (!match) throw new NotFoundException('Match not found.');
|
|
return match;
|
|
}
|
|
|
|
public async serialize(match: MatchDocument) {
|
|
const obj = match.toObject();
|
|
if (obj.result?.games) {
|
|
obj.result.games = [...obj.result.games].sort(
|
|
(left, right) => left.gameNumber - right.gameNumber,
|
|
);
|
|
if (!obj.result.seriesResults?.length) {
|
|
obj.result.seriesResults = this.buildSeriesResults(obj.result.games);
|
|
}
|
|
}
|
|
return {
|
|
...obj,
|
|
gameCount: match.gameCount || DEFAULT_TOURNAMENT_GAME_COUNT,
|
|
gameMode: match.gameMode ?? 'pair',
|
|
participants: (obj.participants ?? []).map((participant) => ({
|
|
...participant,
|
|
excluded: participant.excluded ?? false,
|
|
})),
|
|
teams: (obj.teams ?? []).map((team) => ({
|
|
...team,
|
|
})),
|
|
gameSchedule: obj.gameSchedule ?? [],
|
|
tournamentCodes: await this.tournamentCodeService.buildSlots(match),
|
|
};
|
|
}
|
|
|
|
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' &&
|
|
('maxParticipants' in params.patch ||
|
|
'gameMode' in params.patch ||
|
|
'roundRobinMaxRounds' in params.patch)
|
|
) {
|
|
throw new BadRequestException(
|
|
'maxParticipants, gameMode, and roundRobinMaxRounds can only be changed while recruiting.',
|
|
);
|
|
}
|
|
match.set(params.patch);
|
|
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) {
|
|
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.');
|
|
}
|
|
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.');
|
|
|
|
const match = await MatchModel.findById(params.matchId);
|
|
if (!match) throw new NotFoundException('Match not found.');
|
|
if (!match.communityId.equals(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.length >= match.maxParticipants) {
|
|
throw new BadRequestException('Match is full.');
|
|
}
|
|
const alreadyIn = match.participants.some((p) => p.userId.equals(user._id));
|
|
if (alreadyIn) {
|
|
throw new BadRequestException('User already joined this match.');
|
|
}
|
|
|
|
const selectedRiot = params.riotPuuid
|
|
? user.riotAccounts.find((a) => a.puuid === params.riotPuuid)
|
|
: user.riotAccounts.find((a) => a.isPrimary);
|
|
const selectedTier = this.selectParticipantTier(selectedRiot?.tiers ?? []);
|
|
match.participants.push({
|
|
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,
|
|
});
|
|
await match.save();
|
|
return match;
|
|
}
|
|
|
|
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 match = await MatchModel.findById(params.matchId);
|
|
if (!match) throw new NotFoundException('Match not found.');
|
|
if (!match.communityId.equals(user.communityId)) {
|
|
throw new BadRequestException(
|
|
'User and match belong to different communities.',
|
|
);
|
|
}
|
|
if (match.status !== 'recruiting') {
|
|
throw new BadRequestException('Match is not recruiting.');
|
|
}
|
|
|
|
const participantIndex = match.participants.findIndex((participant) =>
|
|
participant.userId.equals(user._id),
|
|
);
|
|
if (participantIndex === -1) {
|
|
throw new BadRequestException('User has not joined this match.');
|
|
}
|
|
|
|
match.participants.splice(participantIndex, 1);
|
|
await match.save();
|
|
return match;
|
|
}
|
|
|
|
// 관리자 전용 — 특정 참가자를 강제로 제외한다.
|
|
public async removeParticipant(
|
|
params: RemoveParticipantParams,
|
|
): Promise<MatchDocument> {
|
|
const match = await this.loadRecruitingMatch(
|
|
params.matchId,
|
|
params.communityId,
|
|
);
|
|
const participantIndex = match.participants.findIndex((participant) =>
|
|
participant.userId.equals(params.targetUserId),
|
|
);
|
|
if (participantIndex === -1) {
|
|
throw new NotFoundException('Participant not found.');
|
|
}
|
|
match.participants.splice(participantIndex, 1);
|
|
await match.save();
|
|
return match;
|
|
}
|
|
|
|
// 관리자 전용 — 참가자의 주/부 포지션(선호 우선순위 1·2)을 교체한다.
|
|
public async updateParticipantPositions(
|
|
params: UpdateParticipantPositionsParams,
|
|
): Promise<MatchDocument> {
|
|
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.');
|
|
}
|
|
participant.preferredPositions = this.reorderPreferredPositions(
|
|
params.mainPosition,
|
|
params.subPosition,
|
|
participant.preferredPositions,
|
|
);
|
|
match.markModified('participants');
|
|
await match.save();
|
|
return match;
|
|
}
|
|
|
|
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;
|
|
}
|
|
|
|
// 주/부 포지션을 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;
|
|
}
|
|
|
|
private buildSeriesResults(
|
|
games: NonNullable<Match['result']>['games'],
|
|
): 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()];
|
|
}
|
|
}
|