500 lines
15 KiB
TypeScript
500 lines
15 KiB
TypeScript
import type {
|
|
CompetitionCommandResponse,
|
|
CompetitionDetailResponse,
|
|
CompetitionFactsResponse,
|
|
SeriesReversalPreviewResponse,
|
|
TeamCompetitionViewResponse,
|
|
} from '@lolympus/contracts';
|
|
import {
|
|
Body,
|
|
Controller,
|
|
Get,
|
|
Headers,
|
|
HttpException,
|
|
Param,
|
|
Post,
|
|
Query,
|
|
Res,
|
|
UseGuards,
|
|
} from '@nestjs/common';
|
|
import type { Response } from 'express';
|
|
import mongoose from 'mongoose';
|
|
import { plainToInstance } from 'class-transformer';
|
|
import { validateSync, type ValidationError } from 'class-validator';
|
|
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 { UserDocument } from '../global/database/schema';
|
|
import { CompetitionCommandService } from './competition-command.service';
|
|
import { presentCompetitionDetail } from './competition.presenter';
|
|
import { CompetitionQueryService } from './competition-query.service';
|
|
import {
|
|
AcceptCompetitionGameDto,
|
|
AdjudicateCompetitionSeriesDto,
|
|
CompetitionFactsQueryDto,
|
|
PreviewCompetitionSeriesReversalDto,
|
|
ReverseCompetitionSeriesDto,
|
|
} from './dto/competition-command.dto';
|
|
|
|
@Controller('communities/:communityId/matches/:matchId/competition')
|
|
export class CompetitionController {
|
|
constructor(
|
|
private readonly queryService: CompetitionQueryService,
|
|
private readonly commandService: CompetitionCommandService,
|
|
) {}
|
|
|
|
@Get()
|
|
@AllowPublicAccess()
|
|
public async getDetail(
|
|
@Param('communityId', ParseObjectIdPipe)
|
|
communityId: mongoose.Types.ObjectId,
|
|
@Param('matchId', ParseObjectIdPipe) matchId: mongoose.Types.ObjectId,
|
|
@Res({ passthrough: true }) response: Response,
|
|
): Promise<CompetitionDetailResponse> {
|
|
return this.translate(async () => {
|
|
const competition = await this.queryService.getCompetition({
|
|
communityId,
|
|
matchId,
|
|
});
|
|
response.setHeader('ETag', revisionEtag(competition.revision));
|
|
return presentCompetitionDetail(competition as never);
|
|
});
|
|
}
|
|
|
|
@Get('team')
|
|
public async getTeamView(
|
|
@CurrentUser() currentUser: UserDocument,
|
|
@Param('communityId', ParseObjectIdPipe)
|
|
communityId: mongoose.Types.ObjectId,
|
|
@Param('matchId', ParseObjectIdPipe) matchId: mongoose.Types.ObjectId,
|
|
@Res({ passthrough: true }) response?: Response,
|
|
): Promise<TeamCompetitionViewResponse> {
|
|
return this.translate(async () => {
|
|
assertSameCommunity(currentUser, communityId);
|
|
const result = await this.queryService.getTeamView({
|
|
communityId,
|
|
matchId,
|
|
userId: currentUser._id,
|
|
});
|
|
response?.setHeader('ETag', revisionEtag(result.revision));
|
|
return result;
|
|
});
|
|
}
|
|
|
|
@Get('facts')
|
|
@Roles('owner', 'admin')
|
|
@UseGuards(RolesGuard)
|
|
public async listFacts(
|
|
@CurrentUser() currentUser: UserDocument,
|
|
@Param('communityId', ParseObjectIdPipe)
|
|
communityId: mongoose.Types.ObjectId,
|
|
@Param('matchId', ParseObjectIdPipe) matchId: mongoose.Types.ObjectId,
|
|
@Query() rawQuery: unknown,
|
|
): Promise<CompetitionFactsResponse> {
|
|
return this.translate(async () => {
|
|
assertSameCommunity(currentUser, communityId);
|
|
const query = validateDto(CompetitionFactsQueryDto, rawQuery);
|
|
return this.queryService.listFacts({
|
|
communityId,
|
|
matchId,
|
|
cursor: query.cursor,
|
|
limit: query.limit,
|
|
});
|
|
});
|
|
}
|
|
|
|
@Post('games/accept')
|
|
@Roles('owner', 'admin')
|
|
@UseGuards(RolesGuard)
|
|
public async acceptGame(
|
|
@CurrentUser() currentUser: UserDocument,
|
|
@Param('communityId', ParseObjectIdPipe)
|
|
communityId: mongoose.Types.ObjectId,
|
|
@Param('matchId', ParseObjectIdPipe) matchId: mongoose.Types.ObjectId,
|
|
@Headers('if-match') ifMatch: string | undefined,
|
|
@Headers('idempotency-key') idempotencyKey: string | undefined,
|
|
@Body() rawBody: unknown,
|
|
): Promise<CompetitionCommandResponse> {
|
|
return this.translate(async () => {
|
|
assertSameCommunity(currentUser, communityId);
|
|
const body = validateDto(AcceptCompetitionGameDto, rawBody);
|
|
const expectedRevision = requireCommandHeaders(ifMatch, idempotencyKey);
|
|
const competition = await this.queryService.getCompetition({
|
|
communityId,
|
|
matchId,
|
|
});
|
|
const result = await this.commandService.acceptGame({
|
|
competitionId: competition._id,
|
|
expectedRevision,
|
|
idempotencyKey: idempotencyKey!,
|
|
actor: { type: 'user', userId: currentUser._id },
|
|
gameId: new mongoose.Types.ObjectId(body.gameId),
|
|
seriesId: new mongoose.Types.ObjectId(body.seriesId),
|
|
gameSlotId: new mongoose.Types.ObjectId(body.gameSlotId),
|
|
ordinal: body.ordinal,
|
|
evidence: { ...body.evidence },
|
|
mapping: { ...body.mapping },
|
|
...(body.startedAt ? { startedAt: body.startedAt } : {}),
|
|
...(body.durationSeconds === undefined
|
|
? {}
|
|
: { durationSeconds: body.durationSeconds }),
|
|
...(body.participants ? { participants: body.participants } : {}),
|
|
...(body.tournamentCode
|
|
? {
|
|
tournamentCode: {
|
|
tournamentCodeId: new mongoose.Types.ObjectId(
|
|
body.tournamentCode.tournamentCodeId,
|
|
),
|
|
riotMatchId: body.tournamentCode.riotMatchId,
|
|
},
|
|
}
|
|
: {}),
|
|
});
|
|
return {
|
|
competition: presentCompetitionDetail(result.competition as never),
|
|
};
|
|
});
|
|
}
|
|
|
|
@Post('series/:seriesId/adjudications')
|
|
@Roles('owner', 'admin')
|
|
@UseGuards(RolesGuard)
|
|
public async adjudicateSeries(
|
|
@CurrentUser() currentUser: UserDocument,
|
|
@Param('communityId', ParseObjectIdPipe)
|
|
communityId: mongoose.Types.ObjectId,
|
|
@Param('matchId', ParseObjectIdPipe) matchId: mongoose.Types.ObjectId,
|
|
@Param('seriesId', ParseObjectIdPipe) seriesId: mongoose.Types.ObjectId,
|
|
@Headers('if-match') ifMatch: string | undefined,
|
|
@Headers('idempotency-key') idempotencyKey: string | undefined,
|
|
@Body() rawBody: unknown,
|
|
): Promise<CompetitionCommandResponse> {
|
|
return this.translate(async () => {
|
|
assertSameCommunity(currentUser, communityId);
|
|
const body = validateDto(AdjudicateCompetitionSeriesDto, rawBody);
|
|
const expectedRevision = requireCommandHeaders(ifMatch, idempotencyKey);
|
|
const competition = await this.queryService.getCompetition({
|
|
communityId,
|
|
matchId,
|
|
});
|
|
const decision =
|
|
body.decision.type === 'administrative-draw'
|
|
? ({ type: 'administrative-draw' } as const)
|
|
: {
|
|
type: body.decision.type,
|
|
winnerTeamId: new mongoose.Types.ObjectId(
|
|
body.decision.winnerTeamId!,
|
|
),
|
|
};
|
|
const result = await this.commandService.adjudicateSeries({
|
|
competitionId: competition._id,
|
|
expectedRevision,
|
|
idempotencyKey: idempotencyKey!,
|
|
actor: { type: 'user', userId: currentUser._id },
|
|
seriesId,
|
|
decision,
|
|
reason: body.reason,
|
|
});
|
|
return {
|
|
competition: presentCompetitionDetail(result.competition as never),
|
|
};
|
|
});
|
|
}
|
|
|
|
@Post('series/:seriesId/reversal-preview')
|
|
@Roles('owner', 'admin')
|
|
@UseGuards(RolesGuard)
|
|
public async previewReversal(
|
|
@CurrentUser() currentUser: UserDocument,
|
|
@Param('communityId', ParseObjectIdPipe)
|
|
communityId: mongoose.Types.ObjectId,
|
|
@Param('matchId', ParseObjectIdPipe) matchId: mongoose.Types.ObjectId,
|
|
@Param('seriesId', ParseObjectIdPipe) seriesId: mongoose.Types.ObjectId,
|
|
@Headers('if-match') ifMatch: string | undefined,
|
|
@Body() rawBody: unknown,
|
|
): Promise<SeriesReversalPreviewResponse> {
|
|
return this.translate(async () => {
|
|
assertSameCommunity(currentUser, communityId);
|
|
const body = validateDto(PreviewCompetitionSeriesReversalDto, rawBody);
|
|
const expectedRevision = requireRevisionHeader(ifMatch);
|
|
const competition = await this.queryService.getCompetition({
|
|
communityId,
|
|
matchId,
|
|
});
|
|
return (await this.commandService.previewSeriesReversal({
|
|
competitionId: competition._id,
|
|
expectedRevision,
|
|
seriesId,
|
|
mode: body.mode,
|
|
})) as SeriesReversalPreviewResponse;
|
|
});
|
|
}
|
|
|
|
@Post('series/:seriesId/reverse')
|
|
@Roles('owner', 'admin')
|
|
@UseGuards(RolesGuard)
|
|
public async reverseSeries(
|
|
@CurrentUser() currentUser: UserDocument,
|
|
@Param('communityId', ParseObjectIdPipe)
|
|
communityId: mongoose.Types.ObjectId,
|
|
@Param('matchId', ParseObjectIdPipe) matchId: mongoose.Types.ObjectId,
|
|
@Param('seriesId', ParseObjectIdPipe) seriesId: mongoose.Types.ObjectId,
|
|
@Headers('if-match') ifMatch: string | undefined,
|
|
@Headers('idempotency-key') idempotencyKey: string | undefined,
|
|
@Body() rawBody: unknown,
|
|
): Promise<CompetitionCommandResponse> {
|
|
return this.translate(async () => {
|
|
assertSameCommunity(currentUser, communityId);
|
|
const body = validateDto(ReverseCompetitionSeriesDto, rawBody);
|
|
const expectedRevision = requireCommandHeaders(ifMatch, idempotencyKey);
|
|
const competition = await this.queryService.getCompetition({
|
|
communityId,
|
|
matchId,
|
|
});
|
|
const result = await this.commandService.reverseSeries({
|
|
competitionId: competition._id,
|
|
expectedRevision,
|
|
idempotencyKey: idempotencyKey!,
|
|
actor: { type: 'user', userId: currentUser._id },
|
|
seriesId,
|
|
mode: body.mode,
|
|
reason: body.reason,
|
|
impactHash: body.impactHash,
|
|
});
|
|
return {
|
|
competition: presentCompetitionDetail(result.competition as never),
|
|
};
|
|
});
|
|
}
|
|
|
|
private async translate<T>(operation: () => Promise<T>): Promise<T> {
|
|
try {
|
|
return await operation();
|
|
} catch (error) {
|
|
throw explicitHttpError(error);
|
|
}
|
|
}
|
|
}
|
|
|
|
function requireCommandHeaders(
|
|
ifMatch: string | undefined,
|
|
idempotencyKey: string | undefined,
|
|
): number {
|
|
const revision = parseRevision(ifMatch);
|
|
if (
|
|
revision === undefined ||
|
|
typeof idempotencyKey !== 'string' ||
|
|
idempotencyKey.trim().length === 0 ||
|
|
idempotencyKey.length > 200
|
|
) {
|
|
throw apiHttpError(
|
|
422,
|
|
'INVALID_COMPETITION_COMMAND_HEADERS',
|
|
'A numeric If-Match revision and non-empty Idempotency-Key are required.',
|
|
);
|
|
}
|
|
return revision;
|
|
}
|
|
|
|
function requireRevisionHeader(ifMatch: string | undefined): number {
|
|
const revision = parseRevision(ifMatch);
|
|
if (revision === undefined) {
|
|
throw apiHttpError(
|
|
422,
|
|
'INVALID_COMPETITION_COMMAND_HEADERS',
|
|
'A numeric If-Match revision is required.',
|
|
);
|
|
}
|
|
return revision;
|
|
}
|
|
|
|
function parseRevision(value: string | undefined): number | undefined {
|
|
if (!value) return undefined;
|
|
const match = /^(?:W\/)?"?(\d+)"?$/.exec(value.trim());
|
|
if (!match) return undefined;
|
|
const revision = Number(match[1]);
|
|
return Number.isSafeInteger(revision) ? revision : undefined;
|
|
}
|
|
|
|
function revisionEtag(revision: number): string {
|
|
return `"${revision}"`;
|
|
}
|
|
|
|
function assertSameCommunity(
|
|
user: UserDocument,
|
|
communityId: mongoose.Types.ObjectId,
|
|
): void {
|
|
if (!user?.communityId?.equals(communityId)) {
|
|
throw apiHttpError(
|
|
403,
|
|
'COMPETITION_COMMUNITY_FORBIDDEN',
|
|
'The authenticated user does not belong to this community.',
|
|
);
|
|
}
|
|
}
|
|
|
|
function explicitHttpError(error: unknown): HttpException {
|
|
if (error instanceof HttpException) {
|
|
const response = error.getResponse();
|
|
if (
|
|
typeof response === 'object' &&
|
|
response !== null &&
|
|
'error' in response
|
|
) {
|
|
return error;
|
|
}
|
|
return apiHttpError(
|
|
error.getStatus(),
|
|
statusCodeName(error.getStatus()),
|
|
typeof response === 'string'
|
|
? response
|
|
: error.message || 'Competition request failed.',
|
|
);
|
|
}
|
|
if (isCodedError(error)) {
|
|
return apiHttpError(
|
|
error.httpStatus ?? codedErrorStatus(error.code),
|
|
error.code,
|
|
error.message,
|
|
error.details,
|
|
);
|
|
}
|
|
return apiHttpError(
|
|
500,
|
|
'COMPETITION_INTERNAL_ERROR',
|
|
'Competition request failed.',
|
|
);
|
|
}
|
|
|
|
function codedErrorStatus(code: string): number {
|
|
switch (code) {
|
|
case 'REVERSAL_SERIES_NOT_FOUND':
|
|
case 'REVERSAL_REASON_REQUIRED':
|
|
return 422;
|
|
case 'REVERSAL_DESCENDANT_ACTIVITY':
|
|
case 'REVERSAL_NO_ACTIVE_RESULT':
|
|
case 'REVERSAL_PREVIEW_STALE':
|
|
case 'DUPLICATE_FACT_ID':
|
|
case 'DUPLICATE_GAME_ID':
|
|
case 'DUPLICATE_RIOT_MATCH_ID':
|
|
case 'DUPLICATE_GAME_SLOT':
|
|
case 'DUPLICATE_GAME_ORDINAL':
|
|
case 'DUPLICATE_ADJUDICATION':
|
|
case 'FACT_ALREADY_REVERSED':
|
|
case 'SERIES_ALREADY_COMPLETED':
|
|
case 'WALKOVER_HAS_ACTIVE_GAMES':
|
|
return 409;
|
|
case 'FACT_REFERENCE_NOT_FOUND':
|
|
case 'FACT_TYPE_INVALID':
|
|
case 'GAME_SLOT_INVALID':
|
|
case 'GAME_ORDINAL_INVALID':
|
|
case 'GAME_SERIES_MISMATCH':
|
|
case 'GAME_TEAM_MISMATCH':
|
|
case 'GAME_WINNER_INVALID':
|
|
case 'SERIES_DEFINITION_INVALID':
|
|
case 'SERIES_PARTICIPANTS_INVALID':
|
|
case 'ADJUDICATION_INVALID':
|
|
case 'ADJUDICATION_DRAW_NOT_ALLOWED':
|
|
return 422;
|
|
default:
|
|
return 500;
|
|
}
|
|
}
|
|
|
|
function statusCodeName(status: number): string {
|
|
switch (status) {
|
|
case 403:
|
|
return 'COMPETITION_FORBIDDEN';
|
|
case 404:
|
|
return 'COMPETITION_NOT_FOUND';
|
|
case 409:
|
|
return 'COMPETITION_CONFLICT';
|
|
case 412:
|
|
return 'STALE_COMPETITION_REVISION';
|
|
case 422:
|
|
return 'INVALID_COMPETITION_REQUEST';
|
|
default:
|
|
return 'COMPETITION_REQUEST_FAILED';
|
|
}
|
|
}
|
|
|
|
function apiHttpError(
|
|
status: number,
|
|
code: string,
|
|
message: string,
|
|
details?: unknown,
|
|
): HttpException {
|
|
return new HttpException(
|
|
{
|
|
error: {
|
|
code,
|
|
message,
|
|
...(details === undefined ? {} : { details }),
|
|
},
|
|
},
|
|
status,
|
|
);
|
|
}
|
|
|
|
function isCodedError(error: unknown): error is {
|
|
code: string;
|
|
message: string;
|
|
httpStatus?: number;
|
|
details?: unknown;
|
|
} {
|
|
return (
|
|
typeof error === 'object' &&
|
|
error !== null &&
|
|
typeof (error as { code?: unknown }).code === 'string' &&
|
|
typeof (error as { message?: unknown }).message === 'string'
|
|
);
|
|
}
|
|
|
|
type DtoConstructor<T extends object> = new () => T;
|
|
|
|
function validateDto<T extends object>(
|
|
constructor: DtoConstructor<T>,
|
|
value: unknown,
|
|
): T {
|
|
if (typeof value !== 'object' || value === null || Array.isArray(value)) {
|
|
throw apiHttpError(
|
|
422,
|
|
'INVALID_COMPETITION_REQUEST',
|
|
'The Competition request body must be an object.',
|
|
);
|
|
}
|
|
const instance = plainToInstance(constructor, value);
|
|
const errors = validateSync(instance, {
|
|
whitelist: true,
|
|
forbidNonWhitelisted: true,
|
|
forbidUnknownValues: true,
|
|
});
|
|
if (errors.length > 0) {
|
|
throw apiHttpError(
|
|
422,
|
|
'INVALID_COMPETITION_REQUEST',
|
|
'The Competition request payload is invalid.',
|
|
{ fields: flattenValidationErrors(errors) },
|
|
);
|
|
}
|
|
return instance;
|
|
}
|
|
|
|
function flattenValidationErrors(
|
|
errors: readonly ValidationError[],
|
|
prefix = '',
|
|
): Array<{ field: string; constraints: string[] }> {
|
|
return errors.flatMap((error) => {
|
|
const field = prefix ? `${prefix}.${error.property}` : error.property;
|
|
const current = error.constraints
|
|
? [{ field, constraints: Object.values(error.constraints) }]
|
|
: [];
|
|
return [
|
|
...current,
|
|
...flattenValidationErrors(error.children ?? [], field),
|
|
];
|
|
});
|
|
}
|