SendouQ match · Repositories

3 modules · 17 exports · 5 repositories · 13 e2e tests · 1 route

OverviewModulesRepositoriesPermissionsE2E tests

Every table a function queries, its own helpers included, read or written. Calls to other repositories are listed apart, their tables are on their own page.

GroupMatchContinueVoteRepository

app/features/sendouq-match/GroupMatchContinueVoteRepository.server.ts

Tables

GroupMatchContinueVote

Calls

no other repositories

Imports

no other modules

Used by

1 action1 script1 other

Functions & values

function

findAllByGroupIds

:8

Every continue vote cast in the given groups.

export async function findAllByGroupIds(
	groupIds: number[],
	trx?: Transaction<DB>,
)

TablesGroupMatchContinueVote

Unit tests (2)

• returns
  • empty array without querying when no group ids given
  • votes only for the requested groups with isContinuing as boolean

Actions/q/match/:id

Scriptsscripts/benchmark-db/cases.ts

function

castOwnVote

:34

Records the user's continue vote. A no vote also clears the group's yes votes, cast for a size that no longer applies.

export async function castOwnVote(
	{
		groupId,
		isContinuing,
	}: {
		groupId: number;
		isContinuing: boolean;
	},
	trx?: Transaction<DB>,
)

TablesGroupMatchContinueVote

Actions/q/match/:id

Otherapp/db/GroupMatchContinueVoteFactory.ts

Unit tests not about one export (2)

• cast › updates existing vote on conflict instead of inserting a duplicate
• cast › voting no clears existing yes votes for that group only

MatchSkillRepository

app/features/sendouq-match/MatchSkillRepository.server.ts

Tables

SkillSkillTeamUser

Calls

no other repositories

Imports

no other modules

Used by

1 repository

Functions & values

function

insertMatchSkills

:17

Inserts the new skill rows resulting from a match and their team memberships.

export async function insertMatchSkills(
	skills: InsertMatchSkills,
	trx?: Transaction<DB>,
)

TablesSkillSkillTeamUser

Repositoriessendouq-match/SQMatchRepository.server.ts

PlayerStatRepository

app/features/sendouq-match/PlayerStatRepository.server.ts

Tables

CalendarEventGroupMatchGroupMatchMapGroupMemberMapResultPlayerResultSkillTournamentTournamentDivisionTierTournamentMatchTournamentMatchGameResultTournamentMatchGameResultParticipantTournamentResultTournamentStageTournamentTeamUnvalidatedUserSubmittedImageUserUserSubmittedImage

Calls

no other repositories

Imports

no other modules

Used by

3 loaders1 repository1 script

Functions & values

function

upsertMapResults

no JSDoc:24

export function upsertMapResults(
	results: Pick<
		Tables["MapResult"],
		"losses" | "wins" | "userId" | "mode" | "stageId" | "season"
	>[],
	trx?: Transaction<DB>,
)

TablesMapResult

Repositoriessendouq-match/SQMatchRepository.server.ts

function

findSeasonMapWinrateByUserId

:46

Aggregated map win/loss record for a user in a given season.

export async function findSeasonMapWinrateByUserId({
	userId,
	season,
}: {
	userId: number;
	season: number;
}): Promise<{ wins: number; losses: number }>

TablesMapResult

Loaders/u/:identifier/seasons/stats/u/:identifier/seasons/summary-graphic

Scriptsscripts/benchmark-db/cases.ts

function

findSeasonSetWinrateByUserId

:68

Aggregated set win/loss record for a user in a given season.

export async function findSeasonSetWinrateByUserId({
	userId,
	season,
}: {
	userId: number;
	season: number;
}): Promise<{ wins: number; losses: number }>

TablesPlayerResult

Loaders/u/:identifier/seasons/stats/u/:identifier/seasons/summary-graphic

Scriptsscripts/benchmark-db/cases.ts

function

findSeasonStagesByUserId

:91

Per-stage per-mode win/loss breakdown for a user in a given season.

export async function findSeasonStagesByUserId({
	userId,
	season,
}: {
	userId: number;
	season: number;
})

TablesMapResult

Loaders/u/:identifier/seasons/u/:identifier/seasons/stats/u/:identifier/seasons/summary-graphic

Scriptsscripts/benchmark-db/cases.ts

function

findSeasonMatesEnemiesByUserId

:125

Mates or enemies for a user in a given season, ordered by most sets played together.

export async function findSeasonMatesEnemiesByUserId({
	userId,
	season,
	type,
}: {
	userId: number;
	season: number;
	type: Tables["PlayerResult"]["type"];
})

TablesPlayerResultUserUserSubmittedImage

Loaders/u/:identifier/seasons/u/:identifier/seasons/stats/u/:identifier/seasons/summary-graphic

Scriptsscripts/benchmark-db/cases.ts

function

findSeasonSetScoresByUserId

:153

Oldest-first scores of every set the user played in a season, SendouQ and ranked tournaments.

export async function findSeasonSetScoresByUserId(args: {
	userId: number;
	season: number;
}): Promise<Array<{ ownScore: number; opponentScore: number }>>

TablesGroupMatchGroupMatchMapGroupMemberSkillTournamentMatchTournamentMatchGameResultTournamentMatchGameResultParticipantTournamentStage

Loaders/u/:identifier/seasons/summary-graphic

Scriptsscripts/benchmark-db/cases.ts

function

findSeasonSetParticipantsByUserId

:181

One row per other player of each set the user played in a season, SendouQ and ranked tournaments.

export async function findSeasonSetParticipantsByUserId(args: {
	userId: number;
	season: number;
}): Promise<
	Array<{ otherUserId: number; type: "MATE" | "ENEMY"; playedAt: number }>
>

TablesGroupMatchGroupMemberSkillTournamentMatchTournamentMatchGameResultTournamentMatchGameResultParticipantTournamentStage

Unit tests (2)

• returns
  • every other player of a SendouQ set once, typed by their side
  • nothing for another season

Loaders/u/:identifier/seasons/stats

function

findSeasonBestSetsByUserId

:243

The user's won sets of a season, best first by average opponent ordinal at play time. SendouQ and ranked tournaments; tournament sets need at least two opponents with a calculated skill. Only the best set against each opponent roster is included.

export async function findSeasonBestSetsByUserId({
	userId,
	season,
	limit,
}: {
	userId: number;
	season: number;
	limit: number;
})

TablesCalendarEventGroupMatchGroupMatchMapGroupMemberSkillTournamentMatchTournamentMatchGameResultTournamentMatchGameResultParticipantTournamentStageUser

Loaders/u/:identifier/seasons/summary-graphic

Scriptsscripts/benchmark-db/cases.ts

function

findSeasonTournamentPlacementsByUserId

:410

Placement and field size of each of the user's ranked tournament results in a season.

export async function findSeasonTournamentPlacementsByUserId({
	userId,
	season,
}: {
	userId: number;
	season: number;
})

TablesSkillTournamentResult

Loaders/u/:identifier/seasons/stats

function

findSeasonTournamentRunsByUserId

:431

The user's ranked tournament results of a season with tier, field size and the average end-of-season ordinal of the top 8, for picking their best run.

export async function findSeasonTournamentRunsByUserId({
	userId,
	season,
}: {
	userId: number;
	season: number;
})

TablesCalendarEventSkillTournamentTournamentDivisionTierTournamentResultTournamentTeamUnvalidatedUserSubmittedImage

Loaders/u/:identifier/seasons/summary-graphic

Scriptsscripts/benchmark-db/cases.ts

function

upsertPlayerResults

no JSDoc:509

export function upsertPlayerResults(
	results: Tables["PlayerResult"][],
	trx?: Transaction<DB>,
)

TablesPlayerResult

Repositoriessendouq-match/SQMatchRepository.server.ts

ReportedWeaponRepository

app/features/sendouq-match/ReportedWeaponRepository.server.ts

Tables

GroupMatchGroupMatchMapGroupMemberReportedWeaponTournamentTournamentMatchTournamentStage

Calls

no other repositories

Imports

Seasons

Used by

6 loaders2 actions1 route1 repository1 script3 other

Types

interface

WeaponUsageStat

no JSDoc:248

export interface WeaponUsageStat {
	type: "SELF" | "MATE" | "ENEMY";
	weaponSplId: MainWeaponId;
	count: number;
	wins: number;
	losses: number;
}

Only used inside the module

Functions & values

function

upsertOwn

no JSDoc:15

export async function upsertOwn({
	groupMatchId,
	mapIndex,
	weaponSplId,
}: Omit<TablesInsertable["ReportedWeapon"], "userId"> & {
	groupMatchId: number;
	mapIndex: number;
})

TablesReportedWeapon

Actions/q/match/:id

Otherapp/db/SQReportedWeaponFactory.ts

function

replaceByMatchId

no JSDoc:37

export async function replaceByMatchId(
	matchId: number,
	weapons: Omit<Tables["ReportedWeapon"], "createdAt">[],
	trx?: Transaction<DB>,
)

TablesReportedWeapon

Repositoriessendouq-match/SQMatchRepository.server.ts

function

deleteByMatchId

no JSDoc:52

export async function deleteByMatchId(matchId: number, trx?: Transaction<DB>)

TablesReportedWeapon

Repositoriessendouq-match/SQMatchRepository.server.ts

function

deleteOwnByMapIndex

no JSDoc:59

export async function deleteOwnByMapIndex({
	matchId,
	mapIndex,
}: {
	matchId: number;
	mapIndex: number;
})

TablesReportedWeapon

Actions/q/match/:id

function

deleteByMapIndex

no JSDoc:74

export async function deleteByMapIndex(
	{
		matchId,
		mapIndex,
	}: {
		matchId: number;
		mapIndex: number;
	},
	trx?: Transaction<DB>,
)

TablesReportedWeapon

Repositoriessendouq-match/SQMatchRepository.server.ts

function

findByMatchId

no JSDoc:91

export async function findByMatchId(matchId: number)

TablesReportedWeapon

Loaders/q/match/:id

Scriptsscripts/benchmark-db/cases.ts

function

upsertOwnTournament

no JSDoc:111

export async function upsertOwnTournament({
	tournamentMatchId,
	mapIndex,
	weaponSplId,
	createdAt,
}: Omit<TablesInsertable["ReportedWeapon"], "userId"> & {
	tournamentMatchId: number;
	mapIndex: number;
	createdAt: number;
})

TablesReportedWeapon

Actions/to/:id/matches/:mid

Otherapp/db/TournamentReportedWeaponFactory.ts

function

deleteOwnByMapIndexTournament

no JSDoc:135

export async function deleteOwnByMapIndexTournament({
	tournamentMatchId,
	mapIndex,
}: {
	tournamentMatchId: number;
	mapIndex: number;
})

TablesReportedWeapon

Actions/to/:id/matches/:mid

function

deleteExtraByTournamentMatchId

:151

Deletes weapons reported "in advance" for map indexes beyond the games played; called when a set ends to trim what score undos intentionally left dangling.

export async function deleteExtraByTournamentMatchId(
	{
		tournamentMatchId,
		gameCount,
	}: {
		tournamentMatchId: number;
		gameCount: number;
	},
	trx?: Transaction<DB>,
)

TablesReportedWeapon

Actions/to/:id/matches/:mid

Othertournament-match/reportScore.server.ts

function

findByTournamentMatchId

no JSDoc:168

export async function findByTournamentMatchId(matchId: number)

TablesReportedWeapon

Loaders/to/:id/teams/:tid/comps/to/:id/matches/:mid

Scriptsscripts/benchmark-db/cases.ts

function

findSeasonReportedWeaponsByUserId

:189

A user's reported weapons across SendouQ matches and finalized tournaments within the season's date range.

export async function findSeasonReportedWeaponsByUserId({
	userId,
	season,
}: {
	userId: number;
	season: number;
}): Promise<Array<{ weaponSplId: MainWeaponId; count: number }>>

TablesReportedWeaponTournamentTournamentMatchTournamentStage

Loaders/u/:identifier/seasons/u/:identifier/seasons/stats/u/:identifier/seasons/summary-graphic

Scriptsscripts/benchmark-db/cases.ts

function

findAllWeaponUsageStats

:257

How often a user and their mates/enemies used each weapon on a stage and mode during a season, with win/loss counts.

export async function findAllWeaponUsageStats({
	userId,
	mode,
	stageId,
	season,
}: {
	userId: number;
	mode: ModeShort;
	stageId: StageId;
	season: number;
}): Promise<WeaponUsageStat[]>

TablesGroupMatchGroupMatchMapGroupMemberReportedWeapon

Unit tests (2)

• counts a won map of a match in progress
• ignores maps of a match both teams agreed to cancel

Routes/weapon-usage

Scriptsscripts/benchmark-db/cases.ts

SQMatchRepository

app/features/sendouq-match/SQMatchRepository.server.ts

Tables

AllTeamCalendarEventCalendarEventDateGroupGroupMatchGroupMatchCancelReportGroupMatchCancelReportPlayerGroupMatchContinueVoteGroupMatchMapGroupMemberSkillSkillTeamUserTenStarWeaponTournamentResultUnvalidatedUserSubmittedImageUserUserFriendCodeUserSubmittedImageUserWeaponPool

Calls

ChatRepositorySkillRepositoryScannerIngestRepositoryMatchSkillRepositoryPlayerStatRepositoryReportedWeaponRepositorySQGroupRepository

Imports

SeasonsRejoinVoteSendouQMatchSkillDifference

Used by

3 loaders1 action2 routes1 module1 routine1 script6 other

Types

type

SeasonGroupMatch

no JSDoc:487

export type SeasonGroupMatch = Extract<
	Unpacked<Unpacked<ReturnType<typeof findSeasonResultsByUserId>>>,
	{ type: "GROUP_MATCH" }
>["groupMatch"];

Routes/u/:identifier/seasons

type

SeasonTournamentResult

no JSDoc:492

export type SeasonTournamentResult = Extract<
	Unpacked<Unpacked<ReturnType<typeof findSeasonResultsByUserId>>>,
	{ type: "TOURNAMENT_RESULT" }
>["tournamentResult"];

Routes/u/:identifier/seasons

interface

MatchTiers

:1088

Tiers of a starting match's two groups and of the members they are made of.

export interface MatchTiers {
	groups: Array<{
		id: number;
		tier: TieredSkill["tier"];
		members: Array<{
			userId: number;
			/** `"CALCULATING"` when they have too few ranked sets of the season to have a tier. */
			tier: TieredSkill["tier"] | "CALCULATING";
		}>;
	}>;
}

Othersendouq-match/match.server.ts

type

CancelMatchResult

no JSDoc:1184

export type CancelMatchResult =
	| { status: "CANCEL_REPORTED"; shouldRefreshCaches: false }
	| { status: "CANCEL_CONFIRMED"; shouldRefreshCaches: true }
	| { status: "CANT_CANCEL"; shouldRefreshCaches: false }
	| { status: "DUPLICATE"; shouldRefreshCaches: false };

Only used inside the module

type

RequestCancelResult

no JSDoc:1283

export type RequestCancelResult =
	| { status: "REQUESTED" }
	| { status: "ALREADY_LOCKED" }
	| { status: "ALREADY_REQUESTED" };

Only used inside the module

type

AcceptCancelResult

no JSDoc:1338

export type AcceptCancelResult =
	| { status: "ACCEPTED" }
	| { status: "ALREADY_LOCKED" }
	| { status: "NO_CANCEL_REQUEST" }
	| { status: "NOT_ALLOWED" };

Only used inside the module

type

RefuseCancelResult

no JSDoc:1417

export type RefuseCancelResult =
	| { status: "REFUSED" }
	| { status: "ALREADY_LOCKED" }
	| { status: "NO_CANCEL_REQUEST" }
	| { status: "NOT_ALLOWED" };

Only used inside the module

type

ReportMapWinnerResult

no JSDoc:1467

export type ReportMapWinnerResult =
	| { status: "MAP_REPORTED" }
	| { status: "MATCH_REPORTED" }
	| { status: "MATCH_FINALIZED" }
	| { status: "ALREADY_LOCKED" }
	| { status: "INVALID_WINNER" }
	| { status: "SCORE_DISAGREEMENT" }
	| { status: "STALE" };

Only used inside the module

type

ResolveUnfinishedMatchResult

no JSDoc:1850

export type ResolveUnfinishedMatchResult =
	| { status: "CANCELED" }
	| { status: "CONFIRMED" }
	| { status: "ALREADY_LOCKED" };

Only used inside the module

Functions & values

function

exists

:67

Whether a GroupMatch with the given id exists.

export async function exists(id: number)

TablesGroupMatch

Otheruser-report/user-report-schemas.server.ts

function

findAllByChatRoomIds

:78

Matches owning the given chat rooms, with both groups' members' user ids.

export async function findAllByChatRoomIds(chatRoomIds: number[])

TablesGroupMatchGroupMember

Scriptsscripts/benchmark-db/cases.ts

Otherchat/ChatRoomResolver.server.ts

function

findLiveStateById

:112

Just enough of a match to tell still being played apart from over, for the header status.

export async function findLiveStateById(id: number)

TablesGroupMatchSkill

Scriptsscripts/benchmark-db/cases.ts

Otherglobal-status/global-status.server.ts

function

findById

no JSDoc:123

export async function findById(id: number)

TablesAllTeamGroupGroupMatchGroupMatchContinueVoteGroupMatchMapGroupMemberSkillTenStarWeaponUserUserFriendCodeUserSubmittedImageUserWeaponPool

Loaders/q/match/:id

Actions/q/match/:id

Routes/sendouq/match/:matchId

Modulessendouq/SendouQ.server.ts

Scriptsscripts/benchmark-db/cases.ts

Otherapp/db/SQMatchFactory.ts

function

countSeasonResultPagesByUserId

:352

Page count of a user's season results, counting SendouQ matches, ranked tournaments or both per source.

export async function countSeasonResultPagesByUserId({
	userId,
	season,
	source = "ALL",
}: {
	userId: number;
	season: number;
	source?: SeasonResultSource;
}): Promise<number>

TablesSkillTournamentResult

Loaders/u/:identifier/seasons

Scriptsscripts/benchmark-db/cases.ts

function

findSeasonResultsByUserId

:581

A page of a user's season results, SendouQ matches, ranked tournaments or both per source.

export async function findSeasonResultsByUserId({
	userId,
	season,
	page = 1,
	source = "ALL",
}: {
	userId: number;
	season: number;
	page: number;
	source?: SeasonResultSource;
})

TablesCalendarEventCalendarEventDateGroupGroupMatchGroupMatchMapGroupMemberSkillSkillTeamUserTournamentResultUnvalidatedUserSubmittedImageUserUserSubmittedImage

Unit tests (8)

• includes a tournament result only for source $source
• leaves
  • out the SP change while the rating is still being calculated
  • out the roster's SP until the roster is ranked
  • out the roster's SP when the roster the most sets were played with is unranked
• derives
  • the SP change from the rating the tournament replaced
  • the roster's SP change once the roster is ranked
• shows the roster's SP without a change the tournament it becomes ranked
• picks the roster the user played the most sets of the tournament with

Loaders/u/:identifier/seasons

Scriptsscripts/benchmark-db/cases.ts

function

findSeasonDaySummariesByUserId

:732

Summary of each of the given days (yyyy-MM-dd, UTC, ascending) a user played season sets on, SendouQ matches, ranked tournaments or both per source. The SP change is null when every change of the day was made while the rating was still being calculated and so never shown.

export async function findSeasonDaySummariesByUserId({
	userId,
	season,
	source = "ALL",
	dates,
}: {
	userId: number;
	season: number;
	source?: SeasonResultSource;
	dates: string[];
})

TablesCalendarEventCalendarEventDateGroupMatchGroupMatchMapGroupMemberSkillTournamentResult

Unit tests (2)

• tournaments › returns $why× 4
• counts the day's SendouQ sets won and lost

Loaders/u/:identifier/seasons

Scriptsscripts/benchmark-db/cases.ts

function

findSeasonCanceledMatchesByUserId

no JSDoc:829

export async function findSeasonCanceledMatchesByUserId({
	userId,
	season,
}: {
	userId: number;
	season: number;
})

TablesGroupGroupMatchGroupMatchCancelReportGroupMatchCancelReportPlayerGroupMemberSkillUser

Unit tests (1)

• includes both teams' cancel reports with nominated players

Loaders/u/:identifier/seasons

Scriptsscripts/benchmark-db/cases.ts

function

findCancelReportsByGroupMatchId

:899

Returns both teams' cancel reports of a match with the nominated player ids, requester's report first.

export async function findCancelReportsByGroupMatchId(groupMatchId: number)

TablesGroupMatchCancelReportGroupMatchCancelReportPlayer

Actions/q/match/:id

Scriptsscripts/benchmark-db/cases.ts

function

findCancelNominationCountsByUserIds

:927

Counts per user how many canceled matches they have been nominated in as a cause, both within the given season and within the current calendar year. Only finalized cancellations count; a match where both teams nominated the user counts once.

export async function findCancelNominationCountsByUserIds({
	userIds,
	season,
}: {
	userIds: number[];
	season: number;
})

TablesGroupMatchGroupMatchCancelReportGroupMatchCancelReportPlayerSkill

Unit tests (1)

• counts distinct finalized cancellations within season and calendar year

Actions/q/match/:id

Scriptsscripts/benchmark-db/cases.ts

function

insert

:989

Creates a match between two groups, resolving its ready check in the same transaction; only seeds and tests leave readyCheckId out.

export function insert({
	alphaGroupId,
	bravoGroupId,
	mapList,
	tiers,
	readyCheckId,
}: {
	alphaGroupId: number;
	bravoGroupId: number;
	mapList: TournamentMapListMap[];
	/** Tiers the two groups and their members hold as the match starts, snapshotted on them. */
	tiers: MatchTiers;
	readyCheckId?: number;
})

TablesGroupGroupMatchGroupMatchMapGroupMemberUser

CallsChatRepository.insertRoomSQGroupRepository.syncTeamIdSQGroupRepository.deleteLikesAndSuggestionsByGroupIdSQGroupRepository.deleteReadyCheck

Unit tests (2)

• creates an SQ_MATCH chat room owned by the match
• deletes the matched groups' pending likes and suggestions

Otherapp/db/SQMatchFactory.tssendouq/ready-check.server.ts

function

cancelMatch

no JSDoc:1190

export async function cancelMatch({
	matchId,
	isAdminReport,
}: {
	matchId: number;
	isAdminReport?: boolean;
}): Promise<CancelMatchResult>

TablesAllTeamGroupGroupMatchGroupMatchCancelReportGroupMatchContinueVoteGroupMatchMapGroupMemberSkillTenStarWeaponUserUserFriendCodeUserSubmittedImageUserWeaponPool

CallsSQGroupRepository.setAsInactiveReportedWeaponRepository.replaceByMatchIdChatRepository.updateRoomsInactiveReportedWeaponRepository.deleteByMatchId

Unit tests (5)

• first cancel report sets group inactive
• matching cancel confirms and locks match
• cant cancel after score reported
• admin
  • cancel locks match without applying SP changes
  • cancel deletes a pending cancel request's report

Actions/q/match/:id

Otherapp/db/SQMatchFactory.ts

function

requestCancelMatch

no JSDoc:1288

export async function requestCancelMatch({
	matchId,
	requestedByUserId,
	reason,
	nominatedUserIds,
}: {
	matchId: number;
	requestedByUserId: number;
	reason: string;
	nominatedUserIds: number[];
}): Promise<RequestCancelResult>

TablesAllTeamGroupGroupMatchGroupMatchCancelReportGroupMatchCancelReportPlayerGroupMatchContinueVoteGroupMatchMapGroupMemberSkillTenStarWeaponUserUserFriendCodeUserSubmittedImageUserWeaponPool

Unit tests (2)

• stores the requesting team's cancel report with nominated players
• second request does not duplicate the report

Actions/q/match/:id

Otherapp/db/SQMatchFactory.ts

function

acceptCancelMatch

no JSDoc:1344

export async function acceptCancelMatch({
	matchId,
	acceptedByUserId,
	reason,
	nominatedUserIds,
}: {
	matchId: number;
	acceptedByUserId: number;
	reason: string;
	nominatedUserIds: number[];
}): Promise<AcceptCancelResult>

TablesAllTeamGroupGroupMatchGroupMatchCancelReportGroupMatchCancelReportPlayerGroupMatchContinueVoteGroupMatchMapGroupMemberSkillTenStarWeaponUserUserFriendCodeUserSubmittedImageUserWeaponPool

CallsSQGroupRepository.setAsInactiveChatRepository.updateRoomsInactiveReportedWeaponRepository.deleteByMatchId

Unit tests (5)

• stores the accepting team's cancel report and locks the match
• votes the one player both teams nominated out of their group's requeue
• leaves
  • the requeue to a plain vote when the teams nominate different players
  • the requeue to a plain vote when the teams agree on several players
  • an invite-made group free to look again with the nominated player

Actions/q/match/:id

Otherapp/db/SQMatchFactory.ts

function

refuseCancelMatch

no JSDoc:1423

export async function refuseCancelMatch({
	matchId,
	refusedByUserId,
}: {
	matchId: number;
	refusedByUserId: number;
}): Promise<RefuseCancelResult>

TablesAllTeamGroupGroupMatchGroupMatchCancelReportGroupMatchContinueVoteGroupMatchMapGroupMemberSkillTenStarWeaponUserUserFriendCodeUserSubmittedImageUserWeaponPool

Unit tests (1)

• deletes the requester's cancel report

Actions/q/match/:id

function

reportMapWinner

no JSDoc:1476

export async function reportMapWinner({
	matchId,
	winnerId,
	reportedByUserId,
	reportedCount,
	confirmingReportedAt,
	isStaffReport,
}: {
	matchId: number;
	winnerId: number;
	reportedByUserId: number;
	reportedCount: number;
	confirmingReportedAt?: number;
	isStaffReport?: boolean;
}): Promise<ReportMapWinnerResult>

TablesAllTeamGroupGroupMatchGroupMatchCancelReportGroupMatchContinueVoteGroupMatchMapGroupMemberSkillTenStarWeaponUserUserFriendCodeUserSubmittedImageUserWeaponPool

CallsSQGroupRepository.setAsInactiveChatRepository.updateRoomsInactivePlayerStatRepository.upsertMapResultsPlayerStatRepository.upsertPlayerResultsMatchSkillRepository.insertMatchSkillsSkillRepository.findCurrentUserSkillsSkillRepository.findCurrentTeamSkills

Actions/q/match/:id

Otherapp/db/SQMatchFactory.ts

function

findUnfinishedMatchesCreatedBefore

:1817

Matches created before the given cutoff whose score was never confirmed and that no cancellation has locked.

export function findUnfinishedMatchesCreatedBefore(cutoff: Date)

TablesGroupMatchGroupMemberSkill

Routinesapp/routines/resolveStaleSQMatches.ts

function

resolveUnfinishedMatch

:1856

Resolves a never-finished match: cancels when the score is not decisive, else confirms the one report on the other team's behalf. confirmedByUserId stays empty.

export async function resolveUnfinishedMatch(
	matchId: number,
): Promise<ResolveUnfinishedMatchResult>

TablesAllTeamGroupGroupMatchGroupMatchCancelReportGroupMatchContinueVoteGroupMatchMapGroupMemberSkillTenStarWeaponUserUserFriendCodeUserSubmittedImageUserWeaponPool

CallsSQGroupRepository.setAsInactiveChatRepository.updateRoomsInactiveReportedWeaponRepository.deleteByMatchIdPlayerStatRepository.upsertMapResultsPlayerStatRepository.upsertPlayerResultsMatchSkillRepository.insertMatchSkillsSkillRepository.findCurrentUserSkillsSkillRepository.findCurrentTeamSkills

Routinesapp/routines/resolveStaleSQMatches.ts

function

undoMatchReport

no JSDoc:1916

export async function undoMatchReport({
	matchId,
	requestedByUserId,
	isStaff,
}: {
	matchId: number;
	requestedByUserId: number;
	isStaff?: boolean;
}): Promise<{ status: "SUCCESS" | "NOT_ALLOWED" | "ALREADY_LOCKED" }>

TablesAllTeamGroupGroupMatchGroupMatchContinueVoteGroupMatchMapGroupMemberSkillTenStarWeaponUserUserFriendCodeUserSubmittedImageUserWeaponPool

CallsReportedWeaponRepository.deleteByMapIndexScannerIngestRepository.deleteLinksByGroupMatchMapId

Unit tests (1)

• keeps the reporter's group INACTIVE after undoing a set-ending report

Actions/q/match/:id

function

undoMapReport

no JSDoc:1987

export async function undoMapReport({
	matchId,
	mapIndex,
}: {
	matchId: number;
	mapIndex: number;
}): Promise<{ status: "SUCCESS" | "NOT_ALLOWED" | "ALREADY_LOCKED" }>

TablesAllTeamGroupGroupMatchGroupMatchContinueVoteGroupMatchMapGroupMemberSkillTenStarWeaponUserUserFriendCodeUserSubmittedImageUserWeaponPool

CallsReportedWeaponRepository.deleteByMapIndexScannerIngestRepository.deleteLinksByGroupMatchMapId

Actions/q/match/:id

Unit tests not about one export (8)

• finalizeMatch › playing the match out normally deletes a pending cancel request's report
• finalizeMatch › attributes the match to the season it was created in, not the one it is reported in
• finalizeMatch › marks the chat room inactive only once the score is confirmed
• finalizeMatch › concurrent score confirmations finalize the match only once
• reportMapWinner confirmation › rejects as stale a confirmation of a set-ending report undone and re-reported since
• inserts dummy skill to lock match
• marks the chat room inactive
• deletes the match's reported weapons

Not shown, only used by tests: lockMatchWithoutSkillChange