feat(api): implement match history endpoints
This commit is contained in:
1 parent
05407e70a6
commit
b62a3d5edb
8 files changed
+1574
No files matched your search
@@ -0,0 +1,123 @@
|
||||
import { Body, Controller, Get, Param, Post, Query } from '@nestjs/common';
|
||||
import mongoose from 'mongoose';
|
||||
import { AllowPublicAccess } from '../auth/allow-public-access.decorator';
|
||||
import { ParseObjectIdPipe } from '../common/parse-object-id.pipe';
|
||||
import { RiotJobQueueService } from '../riot-job-queue/riot-job-queue.service';
|
||||
import type {
|
||||
RiotJobPriority,
|
||||
} from '../riot-job-queue/riot-job-queue.types';
|
||||
import { MatchHistoryService } from './match-history.service';
|
||||
|
||||
interface RefreshBody {
|
||||
queueGroups?: string[];
|
||||
priority?: RiotJobPriority;
|
||||
}
|
||||
|
||||
@Controller('communities/:communityId/users/:userId')
|
||||
export class MatchHistoryController {
|
||||
constructor(
|
||||
private readonly matchHistoryService: MatchHistoryService,
|
||||
private readonly riotJobQueueService: RiotJobQueueService,
|
||||
) {}
|
||||
|
||||
@Get('history-profile')
|
||||
@AllowPublicAccess()
|
||||
public getProfile(
|
||||
@Param('communityId', ParseObjectIdPipe)
|
||||
communityId: mongoose.Types.ObjectId,
|
||||
@Param('userId', ParseObjectIdPipe) userId: mongoose.Types.ObjectId,
|
||||
) {
|
||||
return this.matchHistoryService.getProfile({ communityId, userId });
|
||||
}
|
||||
|
||||
@Get('champion-stats')
|
||||
@AllowPublicAccess()
|
||||
public getChampionStats(
|
||||
@Param('communityId', ParseObjectIdPipe)
|
||||
communityId: mongoose.Types.ObjectId,
|
||||
@Param('userId', ParseObjectIdPipe) userId: mongoose.Types.ObjectId,
|
||||
@Query('queueGroup') queueGroup?: string,
|
||||
@Query('rank') rank?: string,
|
||||
@Query('seasonId') seasonId?: string,
|
||||
) {
|
||||
return this.matchHistoryService.getChampionStats({
|
||||
communityId,
|
||||
userId,
|
||||
filters: { queueGroup, rank, seasonId },
|
||||
});
|
||||
}
|
||||
|
||||
@Get('recent-summary')
|
||||
@AllowPublicAccess()
|
||||
public getRecentSummary(
|
||||
@Param('communityId', ParseObjectIdPipe)
|
||||
communityId: mongoose.Types.ObjectId,
|
||||
@Param('userId', ParseObjectIdPipe) userId: mongoose.Types.ObjectId,
|
||||
@Query('queueGroup') queueGroup?: string,
|
||||
@Query('rank') rank?: string,
|
||||
@Query('seasonId') seasonId?: string,
|
||||
@Query('championId') championId?: string,
|
||||
@Query('limit') limit?: string,
|
||||
) {
|
||||
return this.matchHistoryService.getRecentSummary({
|
||||
communityId,
|
||||
userId,
|
||||
filters: {
|
||||
queueGroup,
|
||||
rank,
|
||||
seasonId,
|
||||
championId: this.toNumber(championId),
|
||||
limit: this.toNumber(limit),
|
||||
},
|
||||
});
|
||||
}
|
||||
|
||||
@Get('recent-matches')
|
||||
@AllowPublicAccess()
|
||||
public getRecentMatches(
|
||||
@Param('communityId', ParseObjectIdPipe)
|
||||
communityId: mongoose.Types.ObjectId,
|
||||
@Param('userId', ParseObjectIdPipe) userId: mongoose.Types.ObjectId,
|
||||
@Query('queueGroup') queueGroup?: string,
|
||||
@Query('rank') rank?: string,
|
||||
@Query('seasonId') seasonId?: string,
|
||||
@Query('championId') championId?: string,
|
||||
@Query('limit') limit?: string,
|
||||
@Query('cursor') cursor?: string,
|
||||
) {
|
||||
return this.matchHistoryService.getRecentMatches({
|
||||
communityId,
|
||||
userId,
|
||||
filters: {
|
||||
queueGroup,
|
||||
rank,
|
||||
seasonId,
|
||||
championId: this.toNumber(championId),
|
||||
limit: this.toNumber(limit),
|
||||
cursor: this.toNumber(cursor),
|
||||
},
|
||||
});
|
||||
}
|
||||
|
||||
@Post('refresh')
|
||||
@AllowPublicAccess()
|
||||
public refresh(
|
||||
@Param('communityId', ParseObjectIdPipe)
|
||||
communityId: mongoose.Types.ObjectId,
|
||||
@Param('userId', ParseObjectIdPipe) userId: mongoose.Types.ObjectId,
|
||||
@Body() body: RefreshBody,
|
||||
) {
|
||||
return this.riotJobQueueService.enqueueRefresh({
|
||||
communityId,
|
||||
userId,
|
||||
queueGroups: body.queueGroups ?? ['summoners-rift'],
|
||||
priority: body.priority ?? 'high',
|
||||
});
|
||||
}
|
||||
|
||||
private toNumber(value: string | undefined): number | undefined {
|
||||
if (!value) return undefined;
|
||||
const parsed = Number(value);
|
||||
return Number.isFinite(parsed) ? parsed : undefined;
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,12 @@
|
||||
import { Module } from '@nestjs/common';
|
||||
import { RiotJobQueueModule } from '../riot-job-queue/riot-job-queue.module';
|
||||
import { MatchHistoryController } from './match-history.controller';
|
||||
import { MatchHistoryService } from './match-history.service';
|
||||
|
||||
@Module({
|
||||
imports: [RiotJobQueueModule],
|
||||
controllers: [MatchHistoryController],
|
||||
providers: [MatchHistoryService],
|
||||
exports: [MatchHistoryService],
|
||||
})
|
||||
export class MatchHistoryModule {}
|
||||
@@ -0,0 +1,753 @@
|
||||
import { BadRequestException, Injectable, NotFoundException } from '@nestjs/common';
|
||||
import mongoose from 'mongoose';
|
||||
import { ConnectionService } from '../global/database/connection.service';
|
||||
import type {
|
||||
CommunityDocument,
|
||||
RiotAccount,
|
||||
RiotLane,
|
||||
RiotMatchDocument,
|
||||
UserDocument,
|
||||
} from '../global/database/schema';
|
||||
import {
|
||||
isRiotQueueGroup,
|
||||
isRiotRankFilter,
|
||||
RIOT_QUEUE_LABELS,
|
||||
resolveRiotQueueIds,
|
||||
type RiotQueueGroup,
|
||||
type RiotRankFilter,
|
||||
} from '../riot/riot-queue.constants';
|
||||
import type {
|
||||
RiotMatchDto,
|
||||
RiotMatchParticipantDto,
|
||||
} from '../riot/riot.types';
|
||||
import type {
|
||||
ChampionStatsResponse,
|
||||
ChampionStatsRow,
|
||||
HistorySeasonDto,
|
||||
RecentMatchesResponse,
|
||||
RecentMatchView,
|
||||
RecentSummaryResponse,
|
||||
UserHistoryProfileResponse,
|
||||
} from './match-history.types';
|
||||
|
||||
const DEFAULT_QUEUE_GROUP: RiotQueueGroup = 'summoners-rift';
|
||||
const DEFAULT_RANK: RiotRankFilter = 'all';
|
||||
const DEFAULT_RECENT_LIMIT = 10;
|
||||
const DEFAULT_SUMMARY_LIMIT = 20;
|
||||
const MAX_AGGREGATE_MATCHES = 500;
|
||||
const MAX_RECENT_SCAN = 120;
|
||||
|
||||
interface HistoryContext {
|
||||
community: CommunityDocument;
|
||||
user: UserDocument;
|
||||
account: RiotAccount;
|
||||
season: HistorySeasonDto;
|
||||
seasonStartedAt: Date | null;
|
||||
}
|
||||
|
||||
interface MatchFilters {
|
||||
queueGroup?: string;
|
||||
rank?: string;
|
||||
seasonId?: string;
|
||||
championId?: number;
|
||||
limit?: number;
|
||||
cursor?: number;
|
||||
}
|
||||
|
||||
interface AggregatedChampion {
|
||||
championId: number;
|
||||
games: number;
|
||||
wins: number;
|
||||
totalKills: number;
|
||||
totalDeaths: number;
|
||||
totalAssists: number;
|
||||
totalCs: number;
|
||||
totalGameMinutes: number;
|
||||
doubleKills: number;
|
||||
tripleKills: number;
|
||||
quadraKills: number;
|
||||
pentaKills: number;
|
||||
}
|
||||
|
||||
@Injectable()
|
||||
export class MatchHistoryService {
|
||||
constructor(private readonly connectionService: ConnectionService) {}
|
||||
|
||||
public async getProfile(params: {
|
||||
communityId: mongoose.Types.ObjectId;
|
||||
userId: mongoose.Types.ObjectId;
|
||||
}): Promise<UserHistoryProfileResponse> {
|
||||
const context = await this.resolveContext(params);
|
||||
const lastFetchedAt =
|
||||
context.account.recentStatsFetchedAt ??
|
||||
context.account.matchIdsFetchedAt ??
|
||||
null;
|
||||
|
||||
return {
|
||||
userId: context.user._id.toString(),
|
||||
puuid: context.account.puuid,
|
||||
gameName: context.account.gameName,
|
||||
tagLine: context.account.tagLine,
|
||||
profileIconId: context.account.profileIconId,
|
||||
summonerLevel: context.account.summonerLevel,
|
||||
tiers: context.account.tiers.map((tier) => ({
|
||||
queueType: tier.queueType,
|
||||
tier: tier.tier,
|
||||
rank: tier.rank,
|
||||
leaguePoints: tier.leaguePoints,
|
||||
wins: tier.wins,
|
||||
losses: tier.losses,
|
||||
fetchedAt: tier.fetchedAt.toISOString(),
|
||||
})),
|
||||
season: context.season,
|
||||
seasons: this.resolveSeasons(context.community),
|
||||
lastFetchedAt: lastFetchedAt?.toISOString() ?? null,
|
||||
};
|
||||
}
|
||||
|
||||
public async getChampionStats(params: {
|
||||
communityId: mongoose.Types.ObjectId;
|
||||
userId: mongoose.Types.ObjectId;
|
||||
filters: MatchFilters;
|
||||
}): Promise<ChampionStatsResponse> {
|
||||
const context = await this.resolveContext({
|
||||
...params,
|
||||
seasonId: params.filters.seasonId,
|
||||
});
|
||||
const { queueGroup, rank, queueIds } = this.resolveQueueFilters(
|
||||
params.filters,
|
||||
);
|
||||
const docs = await this.findStoredMatches({
|
||||
context,
|
||||
queueIds,
|
||||
limit: MAX_AGGREGATE_MATCHES,
|
||||
});
|
||||
const aggregates = new Map<number, AggregatedChampion>();
|
||||
|
||||
for (const doc of docs) {
|
||||
const dto = doc.raw as unknown as RiotMatchDto;
|
||||
const participant = this.findParticipant(dto, context.account.puuid);
|
||||
if (!participant) continue;
|
||||
const aggregate =
|
||||
aggregates.get(participant.championId) ??
|
||||
this.createChampionAggregate(participant.championId);
|
||||
this.addParticipantToChampionAggregate(aggregate, participant, dto);
|
||||
aggregates.set(participant.championId, aggregate);
|
||||
}
|
||||
|
||||
const champions = [...aggregates.values()]
|
||||
.map((aggregate) => this.toChampionStatsRow(aggregate))
|
||||
.sort((a, b) => b.games - a.games || b.winRate - a.winRate);
|
||||
const totals = this.toChampionStatsRow(
|
||||
[...aggregates.values()].reduce(
|
||||
(acc, aggregate) => this.mergeChampionAggregate(acc, aggregate),
|
||||
this.createChampionAggregate(0),
|
||||
),
|
||||
);
|
||||
|
||||
return {
|
||||
queueGroup,
|
||||
rank,
|
||||
queueIds,
|
||||
season: context.season,
|
||||
lastFetchedAt: this.resolveLastFetchedAt(docs, context),
|
||||
champions,
|
||||
totals,
|
||||
};
|
||||
}
|
||||
|
||||
public async getRecentSummary(params: {
|
||||
communityId: mongoose.Types.ObjectId;
|
||||
userId: mongoose.Types.ObjectId;
|
||||
filters: MatchFilters;
|
||||
}): Promise<RecentSummaryResponse> {
|
||||
const context = await this.resolveContext({
|
||||
...params,
|
||||
seasonId: params.filters.seasonId,
|
||||
});
|
||||
const { queueIds } = this.resolveQueueFilters(params.filters);
|
||||
const limit = this.clampLimit(params.filters.limit, DEFAULT_SUMMARY_LIMIT, 50);
|
||||
const docs = await this.findStoredMatches({
|
||||
context,
|
||||
queueIds,
|
||||
championId: params.filters.championId,
|
||||
limit,
|
||||
scanLimit: params.filters.championId ? MAX_RECENT_SCAN : undefined,
|
||||
});
|
||||
const views = docs
|
||||
.map((doc) => this.toRecentMatchView(doc, context.account.puuid))
|
||||
.filter((view): view is RecentMatchView => Boolean(view))
|
||||
.slice(0, limit);
|
||||
|
||||
return this.createRecentSummary(views, docs, context, limit);
|
||||
}
|
||||
|
||||
public async getRecentMatches(params: {
|
||||
communityId: mongoose.Types.ObjectId;
|
||||
userId: mongoose.Types.ObjectId;
|
||||
filters: MatchFilters;
|
||||
}): Promise<RecentMatchesResponse> {
|
||||
const context = await this.resolveContext({
|
||||
...params,
|
||||
seasonId: params.filters.seasonId,
|
||||
});
|
||||
const { queueIds } = this.resolveQueueFilters(params.filters);
|
||||
const limit = this.clampLimit(params.filters.limit, DEFAULT_RECENT_LIMIT, 30);
|
||||
const docs = await this.findStoredMatches({
|
||||
context,
|
||||
queueIds,
|
||||
championId: params.filters.championId,
|
||||
limit: limit + 1,
|
||||
cursor: params.filters.cursor,
|
||||
scanLimit: params.filters.championId ? MAX_RECENT_SCAN : undefined,
|
||||
});
|
||||
const views = docs
|
||||
.map((doc) => this.toRecentMatchView(doc, context.account.puuid))
|
||||
.filter((view): view is RecentMatchView => Boolean(view));
|
||||
const page = views.slice(0, limit);
|
||||
|
||||
return {
|
||||
matches: page,
|
||||
nextCursor: views.length > limit ? page[page.length - 1]?.gameCreation ?? null : null,
|
||||
lastFetchedAt: this.resolveLastFetchedAt(docs, context),
|
||||
season: context.season,
|
||||
};
|
||||
}
|
||||
|
||||
private async resolveContext(params: {
|
||||
communityId: mongoose.Types.ObjectId;
|
||||
userId: mongoose.Types.ObjectId;
|
||||
seasonId?: string;
|
||||
}): Promise<HistoryContext> {
|
||||
const UserModel = await this.connectionService.getModel('user');
|
||||
const CommunityModel = await this.connectionService.getModel('community');
|
||||
const [user, community] = await Promise.all([
|
||||
UserModel.findById(params.userId).exec(),
|
||||
CommunityModel.findById(params.communityId).exec(),
|
||||
]);
|
||||
|
||||
if (!community) throw new NotFoundException('Community not found.');
|
||||
if (!user || !user.communityId.equals(params.communityId)) {
|
||||
throw new NotFoundException('User not found.');
|
||||
}
|
||||
|
||||
const account =
|
||||
user.riotAccounts.find((riotAccount) => riotAccount.isPrimary) ??
|
||||
user.riotAccounts[0];
|
||||
if (!account) {
|
||||
throw new NotFoundException('Riot account not found.');
|
||||
}
|
||||
|
||||
const season = this.resolveSeason(community, params.seasonId);
|
||||
const seasonStartedAt = season.startedAt
|
||||
? new Date(season.startedAt)
|
||||
: (community.seasonStartedAt ?? null);
|
||||
return { community, user, account, season, seasonStartedAt };
|
||||
}
|
||||
|
||||
private resolveSeason(
|
||||
community: CommunityDocument,
|
||||
seasonId?: string,
|
||||
): HistorySeasonDto {
|
||||
const seasons = this.resolveSeasons(community);
|
||||
if (seasonId && seasonId !== 'current') {
|
||||
const selected = seasons.find((season) => season.id === seasonId);
|
||||
if (!selected) throw new BadRequestException('Invalid seasonId.');
|
||||
return selected;
|
||||
}
|
||||
|
||||
const configured =
|
||||
seasons.find((season) => !season.endedAt) ??
|
||||
[...seasons].sort((left, right) =>
|
||||
(right.startedAt ?? '').localeCompare(left.startedAt ?? ''),
|
||||
)[0];
|
||||
|
||||
if (configured) return configured;
|
||||
|
||||
return {
|
||||
id: 'current',
|
||||
label: '현재 시즌',
|
||||
startedAt: community.seasonStartedAt?.toISOString() ?? null,
|
||||
endedAt: null,
|
||||
};
|
||||
}
|
||||
|
||||
private resolveSeasons(community: CommunityDocument): HistorySeasonDto[] {
|
||||
const configured = community.seasons?.map((season) => ({
|
||||
id: season.id,
|
||||
label: season.label,
|
||||
startedAt: season.startedAt.toISOString(),
|
||||
endedAt: season.endedAt?.toISOString() ?? null,
|
||||
}));
|
||||
|
||||
if (configured?.length) return configured;
|
||||
|
||||
return [
|
||||
{
|
||||
id: 'current',
|
||||
label: '현재 시즌',
|
||||
startedAt: community.seasonStartedAt?.toISOString() ?? null,
|
||||
endedAt: null,
|
||||
},
|
||||
];
|
||||
}
|
||||
|
||||
private resolveQueueFilters(filters: MatchFilters): {
|
||||
queueGroup: RiotQueueGroup;
|
||||
rank: RiotRankFilter;
|
||||
queueIds: number[];
|
||||
} {
|
||||
const queueGroup = filters.queueGroup ?? DEFAULT_QUEUE_GROUP;
|
||||
const rank = filters.rank ?? DEFAULT_RANK;
|
||||
if (!isRiotQueueGroup(queueGroup)) {
|
||||
throw new BadRequestException('Invalid queueGroup.');
|
||||
}
|
||||
if (!isRiotRankFilter(rank)) {
|
||||
throw new BadRequestException('Invalid rank filter.');
|
||||
}
|
||||
return {
|
||||
queueGroup,
|
||||
rank,
|
||||
queueIds: resolveRiotQueueIds(queueGroup, rank),
|
||||
};
|
||||
}
|
||||
|
||||
private async findStoredMatches(params: {
|
||||
context: HistoryContext;
|
||||
queueIds: number[];
|
||||
limit: number;
|
||||
cursor?: number;
|
||||
championId?: number;
|
||||
scanLimit?: number;
|
||||
}): Promise<RiotMatchDocument[]> {
|
||||
if (params.queueIds.length === 0) return [];
|
||||
const RiotMatchModel = await this.connectionService.getModel('riotMatch');
|
||||
const gameCreation: Record<string, number> = {};
|
||||
if (params.context.seasonStartedAt) {
|
||||
gameCreation.$gte = params.context.seasonStartedAt.getTime();
|
||||
}
|
||||
if (params.cursor) gameCreation.$lt = params.cursor;
|
||||
|
||||
const query: Record<string, unknown> = {
|
||||
participantPuuids: params.context.account.puuid,
|
||||
queueId: { $in: params.queueIds },
|
||||
};
|
||||
if (Object.keys(gameCreation).length > 0) query.gameCreation = gameCreation;
|
||||
|
||||
const docs = await RiotMatchModel.find(query)
|
||||
.sort({ gameCreation: -1 })
|
||||
.limit(params.scanLimit ?? params.limit)
|
||||
.exec();
|
||||
|
||||
if (!params.championId) return docs.slice(0, params.limit);
|
||||
return docs
|
||||
.filter((doc) => {
|
||||
const participant = this.findParticipant(
|
||||
doc.raw as unknown as RiotMatchDto,
|
||||
params.context.account.puuid,
|
||||
);
|
||||
return participant?.championId === params.championId;
|
||||
})
|
||||
.slice(0, params.limit);
|
||||
}
|
||||
|
||||
private findParticipant(
|
||||
match: RiotMatchDto,
|
||||
puuid: string,
|
||||
): RiotMatchParticipantDto | null {
|
||||
return (
|
||||
match.info.participants.find((participant) => participant.puuid === puuid) ??
|
||||
null
|
||||
);
|
||||
}
|
||||
|
||||
private createChampionAggregate(championId: number): AggregatedChampion {
|
||||
return {
|
||||
championId,
|
||||
games: 0,
|
||||
wins: 0,
|
||||
totalKills: 0,
|
||||
totalDeaths: 0,
|
||||
totalAssists: 0,
|
||||
totalCs: 0,
|
||||
totalGameMinutes: 0,
|
||||
doubleKills: 0,
|
||||
tripleKills: 0,
|
||||
quadraKills: 0,
|
||||
pentaKills: 0,
|
||||
};
|
||||
}
|
||||
|
||||
private addParticipantToChampionAggregate(
|
||||
aggregate: AggregatedChampion,
|
||||
participant: RiotMatchParticipantDto,
|
||||
match: RiotMatchDto,
|
||||
): void {
|
||||
const minutes = this.resolveGameMinutes(match, participant);
|
||||
aggregate.games += 1;
|
||||
aggregate.wins += participant.win ? 1 : 0;
|
||||
aggregate.totalKills += participant.kills;
|
||||
aggregate.totalDeaths += participant.deaths;
|
||||
aggregate.totalAssists += participant.assists;
|
||||
aggregate.totalCs += this.resolveTotalCs(participant);
|
||||
aggregate.totalGameMinutes += minutes;
|
||||
aggregate.doubleKills += this.numberField(participant, 'doubleKills');
|
||||
aggregate.tripleKills += this.numberField(participant, 'tripleKills');
|
||||
aggregate.quadraKills += this.numberField(participant, 'quadraKills');
|
||||
aggregate.pentaKills += this.numberField(participant, 'pentaKills');
|
||||
}
|
||||
|
||||
private mergeChampionAggregate(
|
||||
acc: AggregatedChampion,
|
||||
aggregate: AggregatedChampion,
|
||||
): AggregatedChampion {
|
||||
acc.games += aggregate.games;
|
||||
acc.wins += aggregate.wins;
|
||||
acc.totalKills += aggregate.totalKills;
|
||||
acc.totalDeaths += aggregate.totalDeaths;
|
||||
acc.totalAssists += aggregate.totalAssists;
|
||||
acc.totalCs += aggregate.totalCs;
|
||||
acc.totalGameMinutes += aggregate.totalGameMinutes;
|
||||
acc.doubleKills += aggregate.doubleKills;
|
||||
acc.tripleKills += aggregate.tripleKills;
|
||||
acc.quadraKills += aggregate.quadraKills;
|
||||
acc.pentaKills += aggregate.pentaKills;
|
||||
return acc;
|
||||
}
|
||||
|
||||
private toChampionStatsRow(aggregate: AggregatedChampion): ChampionStatsRow {
|
||||
const losses = aggregate.games - aggregate.wins;
|
||||
return {
|
||||
championId: aggregate.championId,
|
||||
games: aggregate.games,
|
||||
wins: aggregate.wins,
|
||||
losses,
|
||||
winRate: this.percent(aggregate.wins, aggregate.games),
|
||||
avgKills: this.average(aggregate.totalKills, aggregate.games),
|
||||
avgDeaths: this.average(aggregate.totalDeaths, aggregate.games),
|
||||
avgAssists: this.average(aggregate.totalAssists, aggregate.games),
|
||||
kda: this.resolveKda(
|
||||
aggregate.totalKills,
|
||||
aggregate.totalDeaths,
|
||||
aggregate.totalAssists,
|
||||
),
|
||||
totalKills: aggregate.totalKills,
|
||||
totalDeaths: aggregate.totalDeaths,
|
||||
totalAssists: aggregate.totalAssists,
|
||||
doubleKills: aggregate.doubleKills,
|
||||
tripleKills: aggregate.tripleKills,
|
||||
quadraKills: aggregate.quadraKills,
|
||||
pentaKills: aggregate.pentaKills,
|
||||
avgCs: this.average(aggregate.totalCs, aggregate.games),
|
||||
avgCsPerMin: this.average(aggregate.totalCs, aggregate.totalGameMinutes),
|
||||
};
|
||||
}
|
||||
|
||||
private toRecentMatchView(
|
||||
doc: RiotMatchDocument,
|
||||
puuid: string,
|
||||
): RecentMatchView | null {
|
||||
const dto = doc.raw as unknown as RiotMatchDto;
|
||||
const participant = this.findParticipant(dto, puuid);
|
||||
if (!participant) return null;
|
||||
|
||||
const teamParticipants = dto.info.participants.filter(
|
||||
(candidate) => candidate.teamId === participant.teamId,
|
||||
);
|
||||
const teamKills = teamParticipants.reduce(
|
||||
(sum, candidate) => sum + candidate.kills,
|
||||
0,
|
||||
);
|
||||
const minutes = this.resolveGameMinutes(dto, participant);
|
||||
const totalCs = this.resolveTotalCs(participant);
|
||||
const damageShare = this.resolveDamageShare(dto, participant);
|
||||
const rating = this.resolveRating({
|
||||
participant,
|
||||
teamKills,
|
||||
minutes,
|
||||
damageShare,
|
||||
});
|
||||
|
||||
return {
|
||||
matchId: dto.metadata.matchId,
|
||||
queueId: dto.info.queueId,
|
||||
queueLabel: RIOT_QUEUE_LABELS[dto.info.queueId] ?? `큐 ${dto.info.queueId}`,
|
||||
gameCreation: dto.info.gameCreation,
|
||||
gameDuration: dto.info.gameDuration,
|
||||
win: participant.win,
|
||||
remake:
|
||||
this.booleanField(participant, 'gameEndedInEarlySurrender') ||
|
||||
dto.info.gameDuration < 240,
|
||||
championId: participant.championId,
|
||||
championLevel: participant.champLevel,
|
||||
teamPosition: participant.teamPosition || participant.individualPosition,
|
||||
kills: participant.kills,
|
||||
deaths: participant.deaths,
|
||||
assists: participant.assists,
|
||||
kda: this.resolveKda(
|
||||
participant.kills,
|
||||
participant.deaths,
|
||||
participant.assists,
|
||||
),
|
||||
rating,
|
||||
totalCs,
|
||||
csPerMin: this.average(totalCs, minutes),
|
||||
killParticipation: this.percent(
|
||||
participant.kills + participant.assists,
|
||||
teamKills,
|
||||
),
|
||||
visionScore: participant.visionScore,
|
||||
controlWardsBought: this.numberField(
|
||||
participant,
|
||||
'visionWardsBoughtInGame',
|
||||
),
|
||||
wardsPlaced: participant.wardsPlaced,
|
||||
wardsKilled: participant.wardsKilled,
|
||||
damageDealtToChampions: participant.totalDamageDealtToChampions,
|
||||
damageTaken: participant.totalDamageTaken,
|
||||
goldEarned: participant.goldEarned,
|
||||
items: [
|
||||
participant.item0,
|
||||
participant.item1,
|
||||
participant.item2,
|
||||
participant.item3,
|
||||
participant.item4,
|
||||
participant.item5,
|
||||
],
|
||||
trinket: participant.item6,
|
||||
summonerSpells: [participant.summoner1Id, participant.summoner2Id],
|
||||
perks: this.resolvePerks(participant),
|
||||
teams: this.resolveTeams(dto),
|
||||
};
|
||||
}
|
||||
|
||||
private createRecentSummary(
|
||||
views: RecentMatchView[],
|
||||
docs: RiotMatchDocument[],
|
||||
context: HistoryContext,
|
||||
requestedLimit: number,
|
||||
): RecentSummaryResponse {
|
||||
const totals = views.reduce(
|
||||
(acc, view) => {
|
||||
acc.wins += view.win ? 1 : 0;
|
||||
acc.kills += view.kills;
|
||||
acc.deaths += view.deaths;
|
||||
acc.assists += view.assists;
|
||||
return acc;
|
||||
},
|
||||
{ wins: 0, kills: 0, deaths: 0, assists: 0 },
|
||||
);
|
||||
const losses = views.length - totals.wins;
|
||||
const best = views.reduce<RecentMatchView | null>((acc, view) => {
|
||||
if (!acc) return view;
|
||||
return view.deaths === 0 || view.rating > acc.rating ? view : acc;
|
||||
}, null);
|
||||
|
||||
return {
|
||||
windowSize: Math.min(views.length, requestedLimit),
|
||||
winRate: this.percent(totals.wins, views.length),
|
||||
wins: totals.wins,
|
||||
losses,
|
||||
streak: this.resolveStreak(views),
|
||||
kda: this.resolveKda(totals.kills, totals.deaths, totals.assists),
|
||||
avgKills: this.average(totals.kills, views.length),
|
||||
avgDeaths: this.average(totals.deaths, views.length),
|
||||
avgAssists: this.average(totals.assists, views.length),
|
||||
bestRating: best
|
||||
? {
|
||||
rating: best.deaths === 0 ? 'Perfect' : best.rating,
|
||||
kills: best.kills,
|
||||
deaths: best.deaths,
|
||||
assists: best.assists,
|
||||
matchId: best.matchId,
|
||||
}
|
||||
: null,
|
||||
positionRates: this.resolvePositionRates(views),
|
||||
topChampions: this.resolveTopChampions(views),
|
||||
lastFetchedAt: this.resolveLastFetchedAt(docs, context),
|
||||
};
|
||||
}
|
||||
|
||||
private resolveTeams(match: RiotMatchDto): RecentMatchView['teams'] {
|
||||
return match.info.teams.map((team) => ({
|
||||
side: team.teamId as 100 | 200,
|
||||
win: team.win,
|
||||
objectives: {
|
||||
baron: team.objectives?.baron?.kills,
|
||||
dragon: team.objectives?.dragon?.kills,
|
||||
tower: team.objectives?.tower?.kills,
|
||||
},
|
||||
participants: match.info.participants
|
||||
.filter((participant) => participant.teamId === team.teamId)
|
||||
.map((participant) => ({
|
||||
puuid: participant.puuid,
|
||||
gameName: participant.riotIdGameName || participant.summonerName || 'Unknown',
|
||||
tagLine: participant.riotIdTagLine || '',
|
||||
championId: participant.championId,
|
||||
teamPosition: participant.teamPosition || participant.individualPosition,
|
||||
kills: participant.kills,
|
||||
deaths: participant.deaths,
|
||||
assists: participant.assists,
|
||||
})),
|
||||
}));
|
||||
}
|
||||
|
||||
private resolvePerks(participant: RiotMatchParticipantDto): RecentMatchView['perks'] {
|
||||
const primary = participant.perks.styles.find(
|
||||
(style) => style.description === 'primaryStyle',
|
||||
);
|
||||
const sub = participant.perks.styles.find(
|
||||
(style) => style.description === 'subStyle',
|
||||
);
|
||||
return {
|
||||
primaryStyle: primary?.style,
|
||||
subStyle: sub?.style,
|
||||
keystone: primary?.selections[0]?.perk,
|
||||
};
|
||||
}
|
||||
|
||||
private resolvePositionRates(
|
||||
views: RecentMatchView[],
|
||||
): Partial<Record<RiotLane, number>> {
|
||||
const counts = new Map<string, number>();
|
||||
for (const view of views) {
|
||||
if (!view.teamPosition) continue;
|
||||
counts.set(view.teamPosition, (counts.get(view.teamPosition) ?? 0) + 1);
|
||||
}
|
||||
return Object.fromEntries(
|
||||
[...counts.entries()].map(([lane, count]) => [
|
||||
lane,
|
||||
this.percent(count, views.length),
|
||||
]),
|
||||
) as Partial<Record<RiotLane, number>>;
|
||||
}
|
||||
|
||||
private resolveTopChampions(views: RecentMatchView[]): RecentSummaryResponse['topChampions'] {
|
||||
const byChampion = new Map<number, { games: number; wins: number; rating: number }>();
|
||||
for (const view of views) {
|
||||
const stat =
|
||||
byChampion.get(view.championId) ?? { games: 0, wins: 0, rating: 0 };
|
||||
stat.games += 1;
|
||||
stat.wins += view.win ? 1 : 0;
|
||||
stat.rating += view.rating;
|
||||
byChampion.set(view.championId, stat);
|
||||
}
|
||||
return [...byChampion.entries()]
|
||||
.map(([championId, stat]) => ({
|
||||
championId,
|
||||
games: stat.games,
|
||||
winRate: this.percent(stat.wins, stat.games),
|
||||
pickRate: this.percent(stat.games, views.length),
|
||||
avgRating: this.average(stat.rating, stat.games),
|
||||
}))
|
||||
.sort((a, b) => b.games - a.games || b.winRate - a.winRate)
|
||||
.slice(0, 3);
|
||||
}
|
||||
|
||||
private resolveStreak(
|
||||
views: RecentMatchView[],
|
||||
): RecentSummaryResponse['streak'] {
|
||||
if (views.length === 0) return null;
|
||||
const firstWin = views[0].win;
|
||||
let count = 0;
|
||||
for (const view of views) {
|
||||
if (view.win !== firstWin) break;
|
||||
count += 1;
|
||||
}
|
||||
return { type: firstWin ? 'win' : 'loss', count };
|
||||
}
|
||||
|
||||
private resolveRating(params: {
|
||||
participant: RiotMatchParticipantDto;
|
||||
teamKills: number;
|
||||
minutes: number;
|
||||
damageShare: number;
|
||||
}): number {
|
||||
const { participant, teamKills, minutes, damageShare } = params;
|
||||
const kda = this.resolveKda(
|
||||
participant.kills,
|
||||
participant.deaths,
|
||||
participant.assists,
|
||||
);
|
||||
const kp = teamKills > 0 ? (participant.kills + participant.assists) / teamKills : 0;
|
||||
const csPerMin = this.resolveTotalCs(participant) / Math.max(minutes, 1);
|
||||
const visionPerMin = participant.visionScore / Math.max(minutes, 1);
|
||||
const score =
|
||||
Math.min(kda / 6, 1) * 4 +
|
||||
Math.min(kp, 1) * 2 +
|
||||
Math.min(csPerMin / 9, 1) * 2 +
|
||||
Math.min(damageShare / 0.35, 1) +
|
||||
Math.min(visionPerMin / 2, 1);
|
||||
return this.round(score);
|
||||
}
|
||||
|
||||
private resolveDamageShare(
|
||||
match: RiotMatchDto,
|
||||
participant: RiotMatchParticipantDto,
|
||||
): number {
|
||||
const teamDamage = match.info.participants
|
||||
.filter((candidate) => candidate.teamId === participant.teamId)
|
||||
.reduce((sum, candidate) => sum + candidate.totalDamageDealtToChampions, 0);
|
||||
return teamDamage > 0 ? participant.totalDamageDealtToChampions / teamDamage : 0;
|
||||
}
|
||||
|
||||
private resolveTotalCs(participant: RiotMatchParticipantDto): number {
|
||||
return participant.totalMinionsKilled + participant.neutralMinionsKilled;
|
||||
}
|
||||
|
||||
private resolveGameMinutes(
|
||||
match: RiotMatchDto,
|
||||
participant: RiotMatchParticipantDto,
|
||||
): number {
|
||||
return Math.max((participant.timePlayed || match.info.gameDuration) / 60, 1);
|
||||
}
|
||||
|
||||
private resolveKda(kills: number, deaths: number, assists: number): number {
|
||||
return deaths === 0 ? kills + assists : this.round((kills + assists) / deaths);
|
||||
}
|
||||
|
||||
private resolveLastFetchedAt(
|
||||
docs: RiotMatchDocument[],
|
||||
context: HistoryContext,
|
||||
): string | null {
|
||||
if (docs.length === 0) {
|
||||
return context.account.recentStatsFetchedAt?.toISOString() ?? null;
|
||||
}
|
||||
const oldest = docs.reduce((acc, doc) =>
|
||||
doc.fetchedAt.getTime() < acc.getTime() ? doc.fetchedAt : acc,
|
||||
docs[0].fetchedAt);
|
||||
return oldest.toISOString();
|
||||
}
|
||||
|
||||
private clampLimit(value: number | undefined, fallback: number, max: number): number {
|
||||
if (!value || !Number.isFinite(value)) return fallback;
|
||||
return Math.max(1, Math.min(Math.floor(value), max));
|
||||
}
|
||||
|
||||
private percent(value: number, total: number): number {
|
||||
return total > 0 ? Math.round((value / total) * 100) : 0;
|
||||
}
|
||||
|
||||
private average(value: number, total: number): number {
|
||||
return total > 0 ? this.round(value / total) : 0;
|
||||
}
|
||||
|
||||
private round(value: number): number {
|
||||
return Math.round(value * 10) / 10;
|
||||
}
|
||||
|
||||
private numberField(
|
||||
value: RiotMatchParticipantDto,
|
||||
key: string,
|
||||
): number {
|
||||
const field = value[key];
|
||||
return typeof field === 'number' && Number.isFinite(field) ? field : 0;
|
||||
}
|
||||
|
||||
private booleanField(
|
||||
value: RiotMatchParticipantDto,
|
||||
key: string,
|
||||
): boolean {
|
||||
return value[key] === true;
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,146 @@
|
||||
import type { RiotLane } from '../global/database/schema';
|
||||
import type {
|
||||
RiotQueueGroup,
|
||||
RiotRankFilter,
|
||||
} from '../riot/riot-queue.constants';
|
||||
|
||||
export interface HistorySeasonDto {
|
||||
id: string;
|
||||
label: string;
|
||||
startedAt: string | null;
|
||||
endedAt: string | null;
|
||||
}
|
||||
|
||||
export interface UserHistoryProfileResponse {
|
||||
userId: string;
|
||||
puuid: string;
|
||||
gameName: string;
|
||||
tagLine: string;
|
||||
profileIconId: number;
|
||||
summonerLevel: number;
|
||||
tiers: Array<{
|
||||
queueType: string;
|
||||
tier: string;
|
||||
rank: string;
|
||||
leaguePoints: number;
|
||||
wins: number;
|
||||
losses: number;
|
||||
fetchedAt: string;
|
||||
}>;
|
||||
season: HistorySeasonDto;
|
||||
seasons: HistorySeasonDto[];
|
||||
lastFetchedAt: string | null;
|
||||
}
|
||||
|
||||
export interface ChampionStatsRow {
|
||||
championId: number;
|
||||
games: number;
|
||||
wins: number;
|
||||
losses: number;
|
||||
winRate: number;
|
||||
avgKills: number;
|
||||
avgDeaths: number;
|
||||
avgAssists: number;
|
||||
kda: number;
|
||||
totalKills: number;
|
||||
totalDeaths: number;
|
||||
totalAssists: number;
|
||||
doubleKills: number;
|
||||
tripleKills: number;
|
||||
quadraKills: number;
|
||||
pentaKills: number;
|
||||
avgCs: number;
|
||||
avgCsPerMin: number;
|
||||
}
|
||||
|
||||
export interface ChampionStatsResponse {
|
||||
queueGroup: RiotQueueGroup;
|
||||
rank: RiotRankFilter;
|
||||
queueIds: number[];
|
||||
season: HistorySeasonDto;
|
||||
lastFetchedAt: string | null;
|
||||
champions: ChampionStatsRow[];
|
||||
totals: ChampionStatsRow;
|
||||
}
|
||||
|
||||
export interface RecentSummaryResponse {
|
||||
windowSize: number;
|
||||
winRate: number;
|
||||
wins: number;
|
||||
losses: number;
|
||||
streak: { type: 'win' | 'loss'; count: number } | null;
|
||||
kda: number;
|
||||
avgKills: number;
|
||||
avgDeaths: number;
|
||||
avgAssists: number;
|
||||
bestRating: {
|
||||
rating: number | 'Perfect';
|
||||
kills: number;
|
||||
deaths: number;
|
||||
assists: number;
|
||||
matchId: string;
|
||||
} | null;
|
||||
positionRates: Partial<Record<RiotLane, number>>;
|
||||
topChampions: Array<{
|
||||
championId: number;
|
||||
games: number;
|
||||
winRate: number;
|
||||
pickRate: number;
|
||||
avgRating: number;
|
||||
}>;
|
||||
lastFetchedAt: string | null;
|
||||
}
|
||||
|
||||
export interface RecentMatchesResponse {
|
||||
matches: RecentMatchView[];
|
||||
nextCursor: number | null;
|
||||
lastFetchedAt: string | null;
|
||||
season: HistorySeasonDto;
|
||||
}
|
||||
|
||||
export interface RecentMatchView {
|
||||
matchId: string;
|
||||
queueId: number;
|
||||
queueLabel: string;
|
||||
gameCreation: number;
|
||||
gameDuration: number;
|
||||
win: boolean;
|
||||
remake: boolean;
|
||||
championId: number;
|
||||
championLevel: number;
|
||||
teamPosition: string;
|
||||
kills: number;
|
||||
deaths: number;
|
||||
assists: number;
|
||||
kda: number;
|
||||
rating: number;
|
||||
totalCs: number;
|
||||
csPerMin: number;
|
||||
killParticipation: number;
|
||||
visionScore: number;
|
||||
controlWardsBought: number;
|
||||
wardsPlaced: number;
|
||||
wardsKilled: number;
|
||||
damageDealtToChampions: number;
|
||||
damageTaken: number;
|
||||
goldEarned: number;
|
||||
items: number[];
|
||||
trinket: number;
|
||||
summonerSpells: [number, number];
|
||||
perks: { primaryStyle?: number; subStyle?: number; keystone?: number };
|
||||
teams: Array<{
|
||||
side: 100 | 200;
|
||||
win: boolean;
|
||||
objectives?: { baron?: number; dragon?: number; tower?: number };
|
||||
participants: Array<{
|
||||
puuid: string;
|
||||
gameName: string;
|
||||
tagLine: string;
|
||||
championId: number;
|
||||
teamPosition: string;
|
||||
kills: number;
|
||||
deaths: number;
|
||||
assists: number;
|
||||
}>;
|
||||
}>;
|
||||
}
|
||||
@@ -0,0 +1,145 @@
|
||||
import { Type } from 'class-transformer';
|
||||
import {
|
||||
ArrayMaxSize,
|
||||
ArrayMinSize,
|
||||
IsArray,
|
||||
IsDate,
|
||||
IsEnum,
|
||||
IsInt,
|
||||
IsOptional,
|
||||
IsString,
|
||||
MaxLength,
|
||||
Min,
|
||||
MinLength,
|
||||
ValidateNested,
|
||||
} from 'class-validator';
|
||||
import { POSITIONS } from '../../global/database/schema';
|
||||
import type { Position } from '../../global/database/schema';
|
||||
|
||||
export class PositionPreferenceDto {
|
||||
@IsEnum(POSITIONS)
|
||||
position!: Position;
|
||||
|
||||
@IsInt()
|
||||
@Min(1)
|
||||
priority!: number;
|
||||
}
|
||||
|
||||
class MatchScheduleItemDto {
|
||||
@IsString()
|
||||
@MaxLength(32)
|
||||
time!: string;
|
||||
|
||||
@IsString()
|
||||
@MaxLength(128)
|
||||
label!: string;
|
||||
}
|
||||
|
||||
export class CreateMatchDto {
|
||||
@IsString()
|
||||
@MinLength(1)
|
||||
@MaxLength(128)
|
||||
title!: string;
|
||||
|
||||
@IsOptional()
|
||||
@IsString()
|
||||
@MaxLength(2048)
|
||||
description?: string;
|
||||
|
||||
@IsOptional()
|
||||
@IsInt()
|
||||
mapId?: number;
|
||||
|
||||
@IsDate()
|
||||
@Type(() => Date)
|
||||
scheduledAt!: Date;
|
||||
|
||||
@IsOptional()
|
||||
@IsInt()
|
||||
@Min(2)
|
||||
maxParticipants?: number;
|
||||
|
||||
@IsOptional()
|
||||
@IsInt()
|
||||
@Min(1)
|
||||
gameCount?: number;
|
||||
|
||||
@IsOptional()
|
||||
@IsArray()
|
||||
@IsString({ each: true })
|
||||
@ArrayMaxSize(32)
|
||||
prizes?: string[];
|
||||
|
||||
@IsOptional()
|
||||
@IsArray()
|
||||
@IsString({ each: true })
|
||||
@ArrayMaxSize(32)
|
||||
notices?: string[];
|
||||
|
||||
@IsOptional()
|
||||
@IsArray()
|
||||
@ValidateNested({ each: true })
|
||||
@Type(() => MatchScheduleItemDto)
|
||||
@ArrayMaxSize(32)
|
||||
schedule?: MatchScheduleItemDto[];
|
||||
}
|
||||
|
||||
export class UpdateMatchDto {
|
||||
@IsOptional()
|
||||
@IsString()
|
||||
@MaxLength(128)
|
||||
title?: string;
|
||||
|
||||
@IsOptional()
|
||||
@IsString()
|
||||
@MaxLength(2048)
|
||||
description?: string;
|
||||
|
||||
@IsOptional()
|
||||
@IsInt()
|
||||
mapId?: number;
|
||||
|
||||
@IsOptional()
|
||||
@IsDate()
|
||||
@Type(() => Date)
|
||||
scheduledAt?: Date;
|
||||
|
||||
@IsOptional()
|
||||
@IsInt()
|
||||
@Min(2)
|
||||
maxParticipants?: number;
|
||||
|
||||
@IsOptional()
|
||||
@IsInt()
|
||||
@Min(1)
|
||||
gameCount?: number;
|
||||
|
||||
@IsOptional()
|
||||
@IsArray()
|
||||
@IsString({ each: true })
|
||||
prizes?: string[];
|
||||
|
||||
@IsOptional()
|
||||
@IsArray()
|
||||
@IsString({ each: true })
|
||||
notices?: string[];
|
||||
|
||||
@IsOptional()
|
||||
@IsArray()
|
||||
@ValidateNested({ each: true })
|
||||
@Type(() => MatchScheduleItemDto)
|
||||
schedule?: MatchScheduleItemDto[];
|
||||
}
|
||||
|
||||
export class JoinMatchDto {
|
||||
@IsArray()
|
||||
@ArrayMinSize(1)
|
||||
@ArrayMaxSize(5)
|
||||
@ValidateNested({ each: true })
|
||||
@Type(() => PositionPreferenceDto)
|
||||
preferredPositions!: PositionPreferenceDto[];
|
||||
|
||||
@IsOptional()
|
||||
@IsString()
|
||||
userId?: string;
|
||||
}
|
||||
@@ -0,0 +1,169 @@
|
||||
import {
|
||||
BadRequestException,
|
||||
Body,
|
||||
Controller,
|
||||
Delete,
|
||||
Get,
|
||||
HttpCode,
|
||||
HttpStatus,
|
||||
Param,
|
||||
Patch,
|
||||
Post,
|
||||
Query,
|
||||
UseGuards,
|
||||
} from '@nestjs/common';
|
||||
import mongoose from 'mongoose';
|
||||
import { AllowPublicAccess } from '../auth/allow-public-access.decorator';
|
||||
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 {
|
||||
MatchDocument,
|
||||
MatchStatus,
|
||||
UserDocument,
|
||||
} from '../global/database/schema';
|
||||
import {
|
||||
CreateMatchDto,
|
||||
JoinMatchDto,
|
||||
UpdateMatchDto,
|
||||
} from './dto/create-match.dto';
|
||||
import { MatchService } from './match.service';
|
||||
|
||||
@Controller('communities/:communityId/matches')
|
||||
export class MatchController {
|
||||
constructor(private readonly matchService: MatchService) {}
|
||||
|
||||
@Post()
|
||||
@Roles('admin', 'owner')
|
||||
@UseGuards(RolesGuard)
|
||||
public async createMatch(
|
||||
@CurrentUser() currentUser: UserDocument,
|
||||
@Param('communityId', ParseObjectIdPipe)
|
||||
communityId: mongoose.Types.ObjectId,
|
||||
@Body() body: CreateMatchDto,
|
||||
) {
|
||||
this.assertSameCommunity(currentUser, communityId);
|
||||
return this.matchService.create({
|
||||
communityId,
|
||||
hostUserId: currentUser._id,
|
||||
data: {
|
||||
title: body.title,
|
||||
description: body.description ?? '',
|
||||
mapId: body.mapId ?? 11,
|
||||
scheduledAt: body.scheduledAt,
|
||||
maxParticipants: body.maxParticipants ?? 10,
|
||||
gameCount: body.gameCount,
|
||||
prizes: body.prizes ?? [],
|
||||
notices: body.notices ?? [],
|
||||
schedule: body.schedule ?? [],
|
||||
},
|
||||
});
|
||||
}
|
||||
|
||||
// 공개 — 커뮤니티 내 매치 리스트. 로그인 시 본인 참여 여부를 함께 반환.
|
||||
@Get()
|
||||
@AllowPublicAccess()
|
||||
public async listMatches(
|
||||
@CurrentUser() currentUser: UserDocument | undefined,
|
||||
@Param('communityId', ParseObjectIdPipe)
|
||||
communityId: mongoose.Types.ObjectId,
|
||||
@Query('status') status?: MatchStatus,
|
||||
@Query('limit') limit?: string,
|
||||
) {
|
||||
const matches = await this.matchService.list({
|
||||
communityId,
|
||||
status,
|
||||
limit: limit ? Number(limit) : undefined,
|
||||
});
|
||||
if (!currentUser) return { matches };
|
||||
const myId = currentUser._id;
|
||||
return {
|
||||
matches: matches.map((m) => this.annotateJoined(m, myId)),
|
||||
};
|
||||
}
|
||||
|
||||
@Get(':matchId')
|
||||
@AllowPublicAccess()
|
||||
public async getMatch(
|
||||
@Param('matchId', ParseObjectIdPipe) matchId: mongoose.Types.ObjectId,
|
||||
) {
|
||||
const match = await this.matchService.getById(matchId);
|
||||
return this.matchService.serialize(match);
|
||||
}
|
||||
|
||||
@Patch(':matchId')
|
||||
@Roles('admin', 'owner')
|
||||
@UseGuards(RolesGuard)
|
||||
public async updateMatch(
|
||||
@CurrentUser() currentUser: UserDocument,
|
||||
@Param('communityId', ParseObjectIdPipe)
|
||||
communityId: mongoose.Types.ObjectId,
|
||||
@Param('matchId', ParseObjectIdPipe) matchId: mongoose.Types.ObjectId,
|
||||
@Body() body: UpdateMatchDto,
|
||||
) {
|
||||
this.assertSameCommunity(currentUser, communityId);
|
||||
return this.matchService.update({ matchId, communityId, patch: body });
|
||||
}
|
||||
|
||||
@Delete(':matchId')
|
||||
@Roles('admin', 'owner')
|
||||
@UseGuards(RolesGuard)
|
||||
@HttpCode(HttpStatus.NO_CONTENT)
|
||||
public async deleteMatch(
|
||||
@CurrentUser() currentUser: UserDocument,
|
||||
@Param('communityId', ParseObjectIdPipe)
|
||||
communityId: mongoose.Types.ObjectId,
|
||||
@Param('matchId', ParseObjectIdPipe) matchId: mongoose.Types.ObjectId,
|
||||
) {
|
||||
this.assertSameCommunity(currentUser, communityId);
|
||||
await this.matchService.remove({ matchId, communityId });
|
||||
}
|
||||
|
||||
// 공개 — 참여 (로그인된 유저는 자기 자신, 비로그인은 body.userId 사용).
|
||||
@Post(':matchId/participants')
|
||||
@AllowPublicAccess()
|
||||
public async joinMatch(
|
||||
@CurrentUser() currentUser: UserDocument | undefined,
|
||||
@Param('matchId', ParseObjectIdPipe) matchId: mongoose.Types.ObjectId,
|
||||
@Body() body: JoinMatchDto,
|
||||
) {
|
||||
const userId = this.resolveJoinerUserId(currentUser, body.userId);
|
||||
return this.matchService.join({
|
||||
matchId,
|
||||
userId,
|
||||
preferredPositions: body.preferredPositions,
|
||||
});
|
||||
}
|
||||
|
||||
private resolveJoinerUserId(
|
||||
currentUser: UserDocument | undefined,
|
||||
bodyUserId?: string,
|
||||
): mongoose.Types.ObjectId {
|
||||
if (currentUser) return currentUser._id;
|
||||
if (!bodyUserId || !mongoose.isValidObjectId(bodyUserId)) {
|
||||
throw new BadRequestException(
|
||||
'userId is required when not authenticated.',
|
||||
);
|
||||
}
|
||||
return new mongoose.Types.ObjectId(bodyUserId);
|
||||
}
|
||||
|
||||
private annotateJoined(
|
||||
match: MatchDocument,
|
||||
userId: mongoose.Types.ObjectId,
|
||||
) {
|
||||
const obj = match.toObject();
|
||||
const joined = match.participants.some((p) => p.userId.equals(userId));
|
||||
return { ...obj, joined };
|
||||
}
|
||||
|
||||
private assertSameCommunity(
|
||||
user: UserDocument,
|
||||
communityId: mongoose.Types.ObjectId,
|
||||
): void {
|
||||
if (!user.communityId.equals(communityId)) {
|
||||
throw new BadRequestException('Different community.');
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,13 @@
|
||||
import { Module } from '@nestjs/common';
|
||||
import { CommunityStatsModule } from '../community-stats/community-stats.module';
|
||||
import { TournamentCodeModule } from '../tournament-code/tournament-code.module';
|
||||
import { MatchController } from './match.controller';
|
||||
import { MatchService } from './match.service';
|
||||
|
||||
@Module({
|
||||
imports: [TournamentCodeModule, CommunityStatsModule],
|
||||
controllers: [MatchController],
|
||||
providers: [MatchService],
|
||||
exports: [MatchService],
|
||||
})
|
||||
export class MatchModule {}
|
||||
@@ -0,0 +1,213 @@
|
||||
import {
|
||||
BadRequestException,
|
||||
Injectable,
|
||||
NotFoundException,
|
||||
} from '@nestjs/common';
|
||||
import mongoose from 'mongoose';
|
||||
import { CommunityStatsService } from '../community-stats/community-stats.service';
|
||||
import { ConnectionService } from '../global/database/connection.service';
|
||||
import {
|
||||
Match,
|
||||
MatchDocument,
|
||||
MatchStatus,
|
||||
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';
|
||||
|
||||
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;
|
||||
}
|
||||
|
||||
interface JoinMatchParams {
|
||||
matchId: mongoose.Types.ObjectId;
|
||||
userId: mongoose.Types.ObjectId;
|
||||
preferredPositions: PositionPreference[];
|
||||
// 특정 RiotAccount(puuid)로 참가하고 싶을 때 지정. 없으면 primary 사용.
|
||||
riotPuuid?: string;
|
||||
}
|
||||
|
||||
@Injectable()
|
||||
export class MatchService {
|
||||
constructor(
|
||||
private readonly connectionService: ConnectionService,
|
||||
private readonly tournamentCodeService: TournamentCodeService,
|
||||
private readonly communityStatsService: CommunityStatsService,
|
||||
) {}
|
||||
|
||||
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,
|
||||
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: {
|
||||
communityId: mongoose.Types.ObjectId;
|
||||
status?: MatchStatus;
|
||||
} = {
|
||||
communityId: query.communityId,
|
||||
};
|
||||
if (query.status) filter.status = query.status;
|
||||
return MatchModel.find(filter)
|
||||
.sort({ scheduledAt: -1 })
|
||||
.limit(Math.min(query.limit ?? 50, 200))
|
||||
.exec();
|
||||
}
|
||||
|
||||
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,
|
||||
);
|
||||
}
|
||||
return {
|
||||
...obj,
|
||||
gameCount: match.gameCount || DEFAULT_TOURNAMENT_GAME_COUNT,
|
||||
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;
|
||||
match.set(params.patch);
|
||||
if (
|
||||
previousStatus !== 'recruiting' &&
|
||||
match.status === 'recruiting' &&
|
||||
match.tournamentCodeIds.length > 0
|
||||
) {
|
||||
await this.tournamentCodeService.releaseFromMatch(match);
|
||||
match.tournamentCodeIds = [];
|
||||
match.teamBuiltAt = undefined;
|
||||
match.result = undefined;
|
||||
match.resultPollState = undefined;
|
||||
}
|
||||
await match.save();
|
||||
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 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: params.preferredPositions,
|
||||
joinedAt: new Date(),
|
||||
});
|
||||
await match.save();
|
||||
return match;
|
||||
}
|
||||
|
||||
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,
|
||||
};
|
||||
}
|
||||
}
|
||||
Reference in new issue
Block a user