test: define competition series history
This commit is contained in:
1 parent
075fb52848
commit
9f698a8fec
4 files changed
+900
No files matched your search
@@ -0,0 +1,170 @@
|
||||
import type {
|
||||
CompetitionGameView,
|
||||
CompetitionProjection,
|
||||
IsoDateTime,
|
||||
SeriesProjection,
|
||||
} from "@lolympus/contracts";
|
||||
|
||||
export type CompetitionSeriesHistorySeries = Extract<
|
||||
SeriesProjection,
|
||||
{ status: "in-progress" | "completed" }
|
||||
>;
|
||||
|
||||
export interface CompetitionSeriesHistoryRow {
|
||||
series: CompetitionSeriesHistorySeries;
|
||||
games: CompetitionGameView[];
|
||||
occurredAt: IsoDateTime;
|
||||
timestampSource: "game-start" | "decision";
|
||||
}
|
||||
|
||||
export interface CompetitionSeriesHistoryDay {
|
||||
dateKey: string;
|
||||
rows: CompetitionSeriesHistoryRow[];
|
||||
}
|
||||
|
||||
type HistoryProjection = Pick<CompetitionProjection, "series" | "games">;
|
||||
|
||||
export function createCompetitionSeriesHistory(
|
||||
projection: HistoryProjection,
|
||||
timeZone = "Asia/Seoul",
|
||||
): CompetitionSeriesHistoryDay[] {
|
||||
const gamesBySeriesId = new Map<string, CompetitionGameView[]>();
|
||||
for (const game of projection.games) {
|
||||
const seriesGames = gamesBySeriesId.get(game.seriesId) ?? [];
|
||||
seriesGames.push(game);
|
||||
gamesBySeriesId.set(game.seriesId, seriesGames);
|
||||
}
|
||||
|
||||
const rows: CompetitionSeriesHistoryRow[] = [];
|
||||
for (const series of projection.series) {
|
||||
const games = [...(gamesBySeriesId.get(series.seriesId) ?? [])].sort(
|
||||
compareGames,
|
||||
);
|
||||
if (series.status === "in-progress") {
|
||||
const occurredAt = earliestStartedAt(games);
|
||||
if (!occurredAt) continue;
|
||||
rows.push({
|
||||
series,
|
||||
games,
|
||||
occurredAt,
|
||||
timestampSource: "game-start",
|
||||
});
|
||||
continue;
|
||||
}
|
||||
if (series.status !== "completed") continue;
|
||||
|
||||
const gameStartedAt = earliestStartedAt(games);
|
||||
rows.push({
|
||||
series,
|
||||
games,
|
||||
occurredAt: gameStartedAt ?? series.outcome.completedAt,
|
||||
timestampSource: gameStartedAt ? "game-start" : "decision",
|
||||
});
|
||||
}
|
||||
|
||||
rows.sort(compareRows);
|
||||
|
||||
const days: CompetitionSeriesHistoryDay[] = [];
|
||||
for (const row of rows) {
|
||||
const dateKey = dateKeyInTimeZone(row.occurredAt, timeZone);
|
||||
const currentDay = days.at(-1);
|
||||
if (currentDay?.dateKey === dateKey) {
|
||||
currentDay.rows.push(row);
|
||||
} else {
|
||||
days.push({ dateKey, rows: [row] });
|
||||
}
|
||||
}
|
||||
return days;
|
||||
}
|
||||
|
||||
export function getSeriesHistoryStatusLabel(
|
||||
series: CompetitionSeriesHistorySeries,
|
||||
): string {
|
||||
if (series.status === "in-progress") return "진행 중";
|
||||
switch (series.outcome.type) {
|
||||
case "played":
|
||||
return "종료";
|
||||
case "draw":
|
||||
return "무승부";
|
||||
case "walkover":
|
||||
return "부전승";
|
||||
case "forfeit":
|
||||
return "기권승";
|
||||
case "administrative":
|
||||
return "판정";
|
||||
}
|
||||
}
|
||||
|
||||
export function formatSeriesGameDuration(
|
||||
durationSeconds: number,
|
||||
): string | null {
|
||||
if (!Number.isFinite(durationSeconds) || durationSeconds <= 0) return null;
|
||||
const totalSeconds = Math.floor(durationSeconds);
|
||||
const hours = Math.floor(totalSeconds / 3_600);
|
||||
const minutes = Math.floor((totalSeconds % 3_600) / 60);
|
||||
const seconds = totalSeconds % 60;
|
||||
if (hours > 0) {
|
||||
return `${hours}:${padNumber(minutes)}:${padNumber(seconds)}`;
|
||||
}
|
||||
return `${minutes}:${padNumber(seconds)}`;
|
||||
}
|
||||
|
||||
function compareGames(
|
||||
left: CompetitionGameView,
|
||||
right: CompetitionGameView,
|
||||
): number {
|
||||
return (
|
||||
left.ordinal - right.ordinal ||
|
||||
timestampValue(left.startedAt) - timestampValue(right.startedAt) ||
|
||||
left.id.localeCompare(right.id)
|
||||
);
|
||||
}
|
||||
|
||||
function compareRows(
|
||||
left: CompetitionSeriesHistoryRow,
|
||||
right: CompetitionSeriesHistoryRow,
|
||||
): number {
|
||||
return (
|
||||
timestampValue(left.occurredAt) - timestampValue(right.occurredAt) ||
|
||||
left.series.stage.displayOrder - right.series.stage.displayOrder ||
|
||||
left.series.seriesId.localeCompare(right.series.seriesId)
|
||||
);
|
||||
}
|
||||
|
||||
function earliestStartedAt(games: CompetitionGameView[]): IsoDateTime | null {
|
||||
let earliest: { value: number; startedAt: IsoDateTime } | null = null;
|
||||
for (const game of games) {
|
||||
const value = timestampValue(game.startedAt);
|
||||
if (!Number.isFinite(value)) continue;
|
||||
if (!earliest || value < earliest.value) {
|
||||
earliest = { value, startedAt: game.startedAt };
|
||||
}
|
||||
}
|
||||
return earliest?.startedAt ?? null;
|
||||
}
|
||||
|
||||
function dateKeyInTimeZone(value: IsoDateTime, timeZone: string): string {
|
||||
const date = new Date(value);
|
||||
if (Number.isNaN(date.getTime())) return "unknown";
|
||||
const parts = new Intl.DateTimeFormat("en-US", {
|
||||
timeZone,
|
||||
year: "numeric",
|
||||
month: "2-digit",
|
||||
day: "2-digit",
|
||||
}).formatToParts(date);
|
||||
const part = (type: Intl.DateTimeFormatPartTypes) =>
|
||||
parts.find((entry) => entry.type === type)?.value;
|
||||
const year = part("year");
|
||||
const month = part("month");
|
||||
const day = part("day");
|
||||
return year && month && day ? `${year}-${month}-${day}` : "unknown";
|
||||
}
|
||||
|
||||
function timestampValue(value: IsoDateTime): number {
|
||||
const timestamp = Date.parse(value);
|
||||
return Number.isNaN(timestamp) ? Number.POSITIVE_INFINITY : timestamp;
|
||||
}
|
||||
|
||||
function padNumber(value: number): string {
|
||||
return value.toString().padStart(2, "0");
|
||||
}
|
||||
@@ -0,0 +1,477 @@
|
||||
import assert from "node:assert/strict";
|
||||
import test from "node:test";
|
||||
import type {
|
||||
CompetitionGameView,
|
||||
GameId,
|
||||
GameSlotId,
|
||||
SeriesId,
|
||||
SeriesProjection,
|
||||
TeamId,
|
||||
} from "@lolympus/contracts";
|
||||
import {
|
||||
createCompetitionSeriesHistory,
|
||||
formatSeriesGameDuration,
|
||||
getSeriesHistoryStatusLabel,
|
||||
} from "../src/components/competition/competition-series-history.ts";
|
||||
|
||||
test("aggregates Games under their Series and preserves Series slot scores", () => {
|
||||
const teamA = teamId("team-a");
|
||||
const teamB = teamId("team-b");
|
||||
const series = completedSeries({
|
||||
id: "series-score",
|
||||
teamA,
|
||||
teamB,
|
||||
scoreA: 2,
|
||||
scoreB: 1,
|
||||
completedAt: "2026-07-12T13:00:00.000Z",
|
||||
});
|
||||
const laterGame = game({
|
||||
id: "game-later",
|
||||
seriesId: series.seriesId,
|
||||
ordinal: 2,
|
||||
displayNumber: 4,
|
||||
blueTeamId: teamB,
|
||||
redTeamId: teamA,
|
||||
winnerTeamId: teamB,
|
||||
startedAt: "2026-07-12T12:30:00.000Z",
|
||||
});
|
||||
const earlierGame = game({
|
||||
id: "game-earlier",
|
||||
seriesId: series.seriesId,
|
||||
ordinal: 1,
|
||||
displayNumber: 19,
|
||||
blueTeamId: teamA,
|
||||
redTeamId: teamB,
|
||||
winnerTeamId: teamA,
|
||||
startedAt: "2026-07-12T12:00:00.000Z",
|
||||
});
|
||||
|
||||
const history = createCompetitionSeriesHistory({
|
||||
series: [series],
|
||||
games: [laterGame, earlierGame],
|
||||
});
|
||||
|
||||
assert.equal(history.length, 1);
|
||||
assert.equal(history[0].dateKey, "2026-07-12");
|
||||
assert.equal(history[0].rows.length, 1);
|
||||
assert.deepEqual(
|
||||
history[0].rows[0].series.entries.map((entry) => entry.gameWins),
|
||||
[2, 1],
|
||||
);
|
||||
assert.deepEqual(
|
||||
history[0].rows[0].games.map(({ ordinal }) => ordinal),
|
||||
[1, 2],
|
||||
);
|
||||
assert.equal(history[0].rows[0].occurredAt, earlierGame.startedAt);
|
||||
assert.equal(history[0].rows[0].timestampSource, "game-start");
|
||||
});
|
||||
|
||||
test("groups and orders Series by the Asia/Seoul calendar day", () => {
|
||||
const firstDay = playedSeriesWithGame({
|
||||
id: "first-day",
|
||||
displayOrder: 3,
|
||||
startedAt: "2026-07-12T14:55:00.000Z",
|
||||
});
|
||||
const secondDayLater = playedSeriesWithGame({
|
||||
id: "second-day-later",
|
||||
displayOrder: 2,
|
||||
startedAt: "2026-07-12T16:05:00.000Z",
|
||||
});
|
||||
const secondDayEarlier = playedSeriesWithGame({
|
||||
id: "second-day-earlier",
|
||||
displayOrder: 1,
|
||||
startedAt: "2026-07-12T15:05:00.000Z",
|
||||
});
|
||||
|
||||
const history = createCompetitionSeriesHistory({
|
||||
series: [secondDayLater.series, firstDay.series, secondDayEarlier.series],
|
||||
games: [secondDayLater.game, secondDayEarlier.game, firstDay.game],
|
||||
});
|
||||
|
||||
assert.deepEqual(
|
||||
history.map(({ dateKey }) => dateKey),
|
||||
["2026-07-12", "2026-07-13"],
|
||||
);
|
||||
assert.deepEqual(
|
||||
history[1].rows.map(({ series }) => series.seriesId),
|
||||
[secondDayEarlier.series.seriesId, secondDayLater.series.seriesId],
|
||||
);
|
||||
});
|
||||
|
||||
test("includes recorded in-progress Series and game-less completed decisions only", () => {
|
||||
const teamA = teamId("team-a");
|
||||
const teamB = teamId("team-b");
|
||||
const running = inProgressSeries("running-recorded", teamA, teamB, 1, 0);
|
||||
const runningGame = game({
|
||||
id: "running-game",
|
||||
seriesId: running.seriesId,
|
||||
ordinal: 1,
|
||||
displayNumber: 1,
|
||||
blueTeamId: teamA,
|
||||
redTeamId: teamB,
|
||||
winnerTeamId: teamA,
|
||||
startedAt: "2026-07-13T09:00:00.000Z",
|
||||
});
|
||||
const administrative = completedSeries({
|
||||
id: "administrative",
|
||||
teamA,
|
||||
teamB,
|
||||
scoreA: 0,
|
||||
scoreB: 0,
|
||||
completedAt: "2026-07-13T10:00:00.000Z",
|
||||
outcome: "administrative",
|
||||
});
|
||||
const unrecordedRunning = inProgressSeries(
|
||||
"running-unrecorded",
|
||||
teamA,
|
||||
teamB,
|
||||
0,
|
||||
0,
|
||||
);
|
||||
|
||||
const history = createCompetitionSeriesHistory({
|
||||
series: [
|
||||
readySeries("ready", teamA, teamB),
|
||||
waitingSeries("waiting"),
|
||||
inactiveSeries("inactive"),
|
||||
unrecordedRunning,
|
||||
administrative,
|
||||
running,
|
||||
],
|
||||
games: [runningGame],
|
||||
});
|
||||
const rows = history.flatMap(({ rows }) => rows);
|
||||
|
||||
assert.deepEqual(
|
||||
rows.map(({ series }) => series.seriesId),
|
||||
[running.seriesId, administrative.seriesId],
|
||||
);
|
||||
assert.equal(rows[0].timestampSource, "game-start");
|
||||
assert.equal(rows[1].timestampSource, "decision");
|
||||
assert.equal(rows[1].occurredAt, administrative.outcome.completedAt);
|
||||
});
|
||||
|
||||
test("sorts tied timestamps deterministically and ignores orphan Games", () => {
|
||||
const teamA = teamId("team-a");
|
||||
const teamB = teamId("team-b");
|
||||
const earlierDisplayOrder = completedSeries({
|
||||
id: "series-z",
|
||||
teamA,
|
||||
teamB,
|
||||
scoreA: 2,
|
||||
scoreB: 0,
|
||||
displayOrder: 1,
|
||||
completedAt: "2026-07-13T12:00:00.000Z",
|
||||
});
|
||||
const laterDisplayOrder = completedSeries({
|
||||
id: "series-a",
|
||||
teamA,
|
||||
teamB,
|
||||
scoreA: 2,
|
||||
scoreB: 1,
|
||||
displayOrder: 2,
|
||||
completedAt: "2026-07-13T12:00:00.000Z",
|
||||
});
|
||||
const orphanGame = game({
|
||||
id: "orphan-game",
|
||||
seriesId: seriesId("missing-series"),
|
||||
ordinal: 1,
|
||||
displayNumber: 99,
|
||||
blueTeamId: teamA,
|
||||
redTeamId: teamB,
|
||||
winnerTeamId: teamA,
|
||||
startedAt: "2026-07-13T08:00:00.000Z",
|
||||
});
|
||||
|
||||
const rows = createCompetitionSeriesHistory({
|
||||
series: [laterDisplayOrder, earlierDisplayOrder],
|
||||
games: [orphanGame],
|
||||
}).flatMap(({ rows }) => rows);
|
||||
|
||||
assert.deepEqual(
|
||||
rows.map(({ series }) => series.seriesId),
|
||||
[earlierDisplayOrder.seriesId, laterDisplayOrder.seriesId],
|
||||
);
|
||||
assert.equal(rows.every(({ games }) => games.length === 0), true);
|
||||
});
|
||||
|
||||
test("returns explicit status labels for played and adjudicated outcomes", () => {
|
||||
const teamA = teamId("team-a");
|
||||
const teamB = teamId("team-b");
|
||||
|
||||
assert.equal(
|
||||
getSeriesHistoryStatusLabel(
|
||||
inProgressSeries("running", teamA, teamB, 1, 0),
|
||||
),
|
||||
"진행 중",
|
||||
);
|
||||
assert.equal(
|
||||
getSeriesHistoryStatusLabel(
|
||||
completedSeries({ id: "played", teamA, teamB, scoreA: 2, scoreB: 1 }),
|
||||
),
|
||||
"종료",
|
||||
);
|
||||
assert.equal(
|
||||
getSeriesHistoryStatusLabel(
|
||||
completedSeries({
|
||||
id: "draw",
|
||||
teamA,
|
||||
teamB,
|
||||
scoreA: 1,
|
||||
scoreB: 1,
|
||||
outcome: "draw",
|
||||
}),
|
||||
),
|
||||
"무승부",
|
||||
);
|
||||
assert.equal(
|
||||
getSeriesHistoryStatusLabel(
|
||||
completedSeries({
|
||||
id: "walkover",
|
||||
teamA,
|
||||
teamB,
|
||||
scoreA: 0,
|
||||
scoreB: 0,
|
||||
outcome: "walkover",
|
||||
}),
|
||||
),
|
||||
"부전승",
|
||||
);
|
||||
assert.equal(
|
||||
getSeriesHistoryStatusLabel(
|
||||
completedSeries({
|
||||
id: "forfeit",
|
||||
teamA,
|
||||
teamB,
|
||||
scoreA: 1,
|
||||
scoreB: 1,
|
||||
outcome: "forfeit",
|
||||
}),
|
||||
),
|
||||
"기권승",
|
||||
);
|
||||
assert.equal(
|
||||
getSeriesHistoryStatusLabel(
|
||||
completedSeries({
|
||||
id: "administrative",
|
||||
teamA,
|
||||
teamB,
|
||||
scoreA: 0,
|
||||
scoreB: 0,
|
||||
outcome: "administrative",
|
||||
}),
|
||||
),
|
||||
"판정",
|
||||
);
|
||||
});
|
||||
|
||||
test("formats recorded Game duration and omits unknown legacy zero values", () => {
|
||||
assert.equal(formatSeriesGameDuration(1_875), "31:15");
|
||||
assert.equal(formatSeriesGameDuration(3_661), "1:01:01");
|
||||
assert.equal(formatSeriesGameDuration(0), null);
|
||||
assert.equal(formatSeriesGameDuration(-1), null);
|
||||
});
|
||||
|
||||
function playedSeriesWithGame({
|
||||
id,
|
||||
displayOrder,
|
||||
startedAt,
|
||||
}: {
|
||||
id: string;
|
||||
displayOrder: number;
|
||||
startedAt: string;
|
||||
}) {
|
||||
const teamA = teamId(`${id}-a`);
|
||||
const teamB = teamId(`${id}-b`);
|
||||
const series = completedSeries({
|
||||
id,
|
||||
teamA,
|
||||
teamB,
|
||||
scoreA: 2,
|
||||
scoreB: 0,
|
||||
displayOrder,
|
||||
completedAt: startedAt,
|
||||
});
|
||||
return {
|
||||
series,
|
||||
game: game({
|
||||
id: `${id}-game`,
|
||||
seriesId: series.seriesId,
|
||||
ordinal: 1,
|
||||
displayNumber: displayOrder,
|
||||
blueTeamId: teamA,
|
||||
redTeamId: teamB,
|
||||
winnerTeamId: teamA,
|
||||
startedAt,
|
||||
}),
|
||||
};
|
||||
}
|
||||
|
||||
function completedSeries({
|
||||
id,
|
||||
teamA,
|
||||
teamB,
|
||||
scoreA,
|
||||
scoreB,
|
||||
displayOrder = 1,
|
||||
completedAt = "2026-07-13T00:00:00.000Z",
|
||||
outcome = "played",
|
||||
}: {
|
||||
id: string;
|
||||
teamA: TeamId;
|
||||
teamB: TeamId;
|
||||
scoreA: number;
|
||||
scoreB: number;
|
||||
displayOrder?: number;
|
||||
completedAt?: string;
|
||||
outcome?: "played" | "draw" | "walkover" | "forfeit" | "administrative";
|
||||
}): Extract<SeriesProjection, { status: "completed" }> {
|
||||
const base = {
|
||||
seriesId: seriesId(id),
|
||||
stage: { type: "upper" as const, roundNumber: 1, displayOrder },
|
||||
rule: { type: "first-to" as const, winsRequired: 2, maxGames: 3 },
|
||||
status: "completed" as const,
|
||||
entries: [
|
||||
{ slot: "A" as const, teamId: teamA, gameWins: scoreA },
|
||||
{ slot: "B" as const, teamId: teamB, gameWins: scoreB },
|
||||
] as const,
|
||||
};
|
||||
|
||||
if (outcome === "draw") {
|
||||
return {
|
||||
...base,
|
||||
outcome: {
|
||||
type: "draw",
|
||||
basis: { type: "played", decidedByGameIds: [] },
|
||||
completedAt,
|
||||
},
|
||||
};
|
||||
}
|
||||
if (outcome !== "played") {
|
||||
return {
|
||||
...base,
|
||||
outcome: {
|
||||
type: outcome,
|
||||
winnerTeamId: teamA,
|
||||
loserTeamId: teamB,
|
||||
decisionFactId: `fact-${id}` as never,
|
||||
completedAt,
|
||||
},
|
||||
};
|
||||
}
|
||||
return {
|
||||
...base,
|
||||
outcome: {
|
||||
type: "played",
|
||||
winnerTeamId: teamA,
|
||||
loserTeamId: teamB,
|
||||
decidedByGameIds: [],
|
||||
completedAt,
|
||||
},
|
||||
};
|
||||
}
|
||||
|
||||
function inProgressSeries(
|
||||
id: string,
|
||||
teamA: TeamId,
|
||||
teamB: TeamId,
|
||||
scoreA: number,
|
||||
scoreB: number,
|
||||
): Extract<SeriesProjection, { status: "in-progress" }> {
|
||||
return {
|
||||
seriesId: seriesId(id),
|
||||
stage: { type: "upper", roundNumber: 1, displayOrder: 1 },
|
||||
rule: { type: "first-to", winsRequired: 2, maxGames: 3 },
|
||||
status: "in-progress",
|
||||
entries: [
|
||||
{ slot: "A", teamId: teamA, gameWins: scoreA },
|
||||
{ slot: "B", teamId: teamB, gameWins: scoreB },
|
||||
],
|
||||
...(scoreA === scoreB
|
||||
? {}
|
||||
: { leaderTeamId: scoreA > scoreB ? teamA : teamB }),
|
||||
};
|
||||
}
|
||||
|
||||
function readySeries(
|
||||
id: string,
|
||||
teamA: TeamId,
|
||||
teamB: TeamId,
|
||||
): Extract<SeriesProjection, { status: "ready" }> {
|
||||
return {
|
||||
seriesId: seriesId(id),
|
||||
stage: { type: "upper", roundNumber: 1, displayOrder: 1 },
|
||||
rule: { type: "first-to", winsRequired: 2, maxGames: 3 },
|
||||
status: "ready",
|
||||
entries: [
|
||||
{ slot: "A", teamId: teamA, gameWins: 0 },
|
||||
{ slot: "B", teamId: teamB, gameWins: 0 },
|
||||
],
|
||||
};
|
||||
}
|
||||
|
||||
function waitingSeries(
|
||||
id: string,
|
||||
): Extract<SeriesProjection, { status: "waiting" }> {
|
||||
return {
|
||||
seriesId: seriesId(id),
|
||||
stage: { type: "upper", roundNumber: 1, displayOrder: 1 },
|
||||
rule: { type: "first-to", winsRequired: 2, maxGames: 3 },
|
||||
status: "waiting",
|
||||
entries: [
|
||||
{ slot: "A", teamId: null, gameWins: 0 },
|
||||
{ slot: "B", teamId: null, gameWins: 0 },
|
||||
],
|
||||
};
|
||||
}
|
||||
|
||||
function inactiveSeries(
|
||||
id: string,
|
||||
): Extract<SeriesProjection, { status: "inactive" }> {
|
||||
return { ...waitingSeries(id), status: "inactive" };
|
||||
}
|
||||
|
||||
function game({
|
||||
id,
|
||||
seriesId: parentSeriesId,
|
||||
ordinal,
|
||||
displayNumber,
|
||||
blueTeamId,
|
||||
redTeamId,
|
||||
winnerTeamId,
|
||||
startedAt,
|
||||
}: {
|
||||
id: string;
|
||||
seriesId: SeriesId;
|
||||
ordinal: number;
|
||||
displayNumber: number;
|
||||
blueTeamId: TeamId;
|
||||
redTeamId: TeamId;
|
||||
winnerTeamId: TeamId;
|
||||
startedAt: string;
|
||||
}): CompetitionGameView {
|
||||
return {
|
||||
id: id as GameId,
|
||||
seriesId: parentSeriesId,
|
||||
gameSlotId: `${id}-slot` as GameSlotId,
|
||||
ordinal,
|
||||
displayNumber,
|
||||
evidence: { type: "legacy", legacyReference: id },
|
||||
teams: {
|
||||
blue: { side: "blue", teamId: blueTeamId },
|
||||
red: { side: "red", teamId: redTeamId },
|
||||
},
|
||||
winnerTeamId,
|
||||
startedAt,
|
||||
durationSeconds: 1_875,
|
||||
participants: [],
|
||||
};
|
||||
}
|
||||
|
||||
function seriesId(value: string): SeriesId {
|
||||
return value as SeriesId;
|
||||
}
|
||||
|
||||
function teamId(value: string): TeamId {
|
||||
return value as TeamId;
|
||||
}
|
||||
Reference in new issue
Block a user