378 lines
15 KiB
TypeScript
378 lines
15 KiB
TypeScript
import {
|
||
contestPasswordRequestSchema,
|
||
STUDENT_ROLES,
|
||
type Contest,
|
||
type ContestAccess,
|
||
type ContestList,
|
||
type ContestRank,
|
||
type ContestRankItem,
|
||
type ProblemDetail,
|
||
type ProblemListItem,
|
||
} from "@oj2/contract"
|
||
import { and, asc, count, desc, eq, gte, ilike, inArray, lte, sql } from "drizzle-orm"
|
||
import { Hono } from "hono"
|
||
|
||
import { optionalAuth, requireAuth } from "../auth/middleware"
|
||
import { setContestPassword } from "../auth/session"
|
||
import { db, schema } from "../db"
|
||
import { astRequirements } from "../judge/ast"
|
||
import { failure, parseBody, success } from "../http"
|
||
import {
|
||
canAccessContest,
|
||
checkContestPassword,
|
||
contestDetailsAllowed,
|
||
contestStatus,
|
||
findAccessibleContest,
|
||
isContestAdmin,
|
||
requireContestAccess,
|
||
type ContestEnv,
|
||
} from "../services/contest"
|
||
import { countAttempt, lockoutRemaining, type AttemptRule } from "../services/throttling"
|
||
import { asRecord, publicTemplates, queryInteger, sampleUser } from "./helpers"
|
||
|
||
export const contestRoutes = new Hono<ContestEnv>()
|
||
|
||
/** 一次把这批比赛的创建者全查回来，按 userId 建 Map —— 比赛列表按行查会变成 N+1 */
|
||
async function creators(ids: number[]) {
|
||
const map = new Map<number, ReturnType<typeof sampleUser>>()
|
||
if (ids.length === 0) return map
|
||
const rows = await db
|
||
.select({
|
||
id: schema.user.id,
|
||
username: schema.user.username,
|
||
realName: schema.userProfile.realName,
|
||
})
|
||
.from(schema.user)
|
||
.leftJoin(schema.userProfile, eq(schema.userProfile.userId, schema.user.id))
|
||
.where(inArray(schema.user.id, ids))
|
||
for (const row of rows) map.set(row.id, sampleUser(row, row.realName))
|
||
return map
|
||
}
|
||
|
||
function serializeContest(
|
||
contest: typeof schema.contest.$inferSelect,
|
||
createdBy: ReturnType<typeof sampleUser>,
|
||
includeNow = false,
|
||
) {
|
||
return {
|
||
id: contest.id,
|
||
title: contest.title,
|
||
description: contest.description,
|
||
tag: contest.tag,
|
||
startTime: contest.startTime,
|
||
endTime: contest.endTime,
|
||
createTime: contest.createTime,
|
||
lastUpdateTime: contest.lastUpdateTime,
|
||
createdBy,
|
||
status: contestStatus(contest),
|
||
contestType: contest.password ? "Password Protected" : "Public",
|
||
now: includeNow ? new Date().toISOString() : undefined,
|
||
} satisfies Contest
|
||
}
|
||
|
||
contestRoutes.get("/contests", async (c) => {
|
||
const limit = queryInteger(c.req.query("limit"), 10, { min: 1, max: 250 })
|
||
const offset = queryInteger(c.req.query("offset"), 0, { min: 0 })
|
||
const keyword = c.req.query("keyword")?.trim()
|
||
const tag = c.req.query("tag")?.trim()
|
||
const status = c.req.query("status")
|
||
const now = new Date().toISOString()
|
||
const filters = [eq(schema.contest.visible, true)]
|
||
if (keyword) filters.push(ilike(schema.contest.title, `%${keyword}%`))
|
||
if (tag) filters.push(eq(schema.contest.tag, tag))
|
||
if (status === "1") filters.push(gte(schema.contest.startTime, now))
|
||
else if (status === "-1") filters.push(lte(schema.contest.endTime, now))
|
||
else if (status === "0")
|
||
filters.push(and(lte(schema.contest.startTime, now), gte(schema.contest.endTime, now))!)
|
||
const where = and(...filters)
|
||
const [totalRow, rows] = await Promise.all([
|
||
db.select({ value: count() }).from(schema.contest).where(where),
|
||
db
|
||
.select()
|
||
.from(schema.contest)
|
||
.where(where)
|
||
.orderBy(desc(schema.contest.startTime))
|
||
.limit(limit)
|
||
.offset(offset),
|
||
])
|
||
const byId = await creators([...new Set(rows.map((row) => row.createdById))])
|
||
return success(c, {
|
||
results: rows.map((row) =>
|
||
serializeContest(
|
||
row,
|
||
byId.get(row.createdById) ?? sampleUser({ id: row.createdById, username: "" }, null),
|
||
),
|
||
),
|
||
total: totalRow[0]?.value ?? 0,
|
||
} satisfies ContestList)
|
||
})
|
||
|
||
// optionalAuth 是为了下面那句 findAccessibleContest 认得出「这是出题人自己」——
|
||
// 隐藏的比赛只有他看得到详情，匿名访问照旧当作不存在
|
||
contestRoutes.get("/contests/:id", optionalAuth, async (c) => {
|
||
const contest = await findAccessibleContest(
|
||
c.get("user"),
|
||
queryInteger(c.req.param("id"), 0, { min: 1 }),
|
||
)
|
||
if (!contest) return failure(c, 404, "contest-not-found", "Contest does not exist")
|
||
const byId = await creators([contest.createdById])
|
||
return success(
|
||
c,
|
||
serializeContest(
|
||
contest,
|
||
byId.get(contest.createdById) ?? sampleUser({ id: contest.createdById, username: "" }, null),
|
||
true,
|
||
),
|
||
)
|
||
})
|
||
|
||
const CONTEST_PASSWORD_RULE: AttemptRule = { limit: 10, windowSeconds: 10 * 60 }
|
||
|
||
contestRoutes.post("/contests/:id/access", requireAuth, async (c) => {
|
||
const contest = await findAccessibleContest(
|
||
c.get("user"),
|
||
queryInteger(c.req.param("id"), 0, { min: 1 }),
|
||
)
|
||
if (!contest || !contest.password)
|
||
return failure(c, 404, "contest-not-found", "Contest does not exist")
|
||
const parsed = await parseBody(c, contestPasswordRequestSchema, "Password is required")
|
||
if (!parsed.success) return parsed.response
|
||
// 比赛密码往往就是几位数字，不限的话一个脚本几分钟就能扫完。
|
||
// 按「人 × 比赛」计失败次数：猜错的是自己，锁的也只是自己进这一场。
|
||
const attemptKey = `contest-password:${contest.id}:${c.get("user")!.id}`
|
||
const wait = await lockoutRemaining(attemptKey, CONTEST_PASSWORD_RULE)
|
||
if (wait !== null) {
|
||
return failure(
|
||
c,
|
||
429,
|
||
"too-many-password-attempts",
|
||
`Too many wrong passwords, please wait ${wait} seconds`,
|
||
)
|
||
}
|
||
if (!checkContestPassword(parsed.data.password, contest.password)) {
|
||
await countAttempt(attemptKey, CONTEST_PASSWORD_RULE)
|
||
return failure(c, 403, "wrong-password", "Wrong password or password expired")
|
||
}
|
||
await setContestPassword(c, contest.id, parsed.data.password)
|
||
return success(c, true)
|
||
})
|
||
|
||
contestRoutes.get("/contests/:id/access", requireAuth, async (c) => {
|
||
const contest = await findAccessibleContest(
|
||
c.get("user"),
|
||
queryInteger(c.req.param("id"), 0, { min: 1 }),
|
||
)
|
||
if (!contest || !contest.password)
|
||
return failure(c, 404, "contest-not-found", "Contest does not exist")
|
||
const access = await canAccessContest(c, contest, "details")
|
||
return success(c, { access: access.ok } satisfies ContestAccess)
|
||
})
|
||
|
||
/**
|
||
* 当前用户在**比赛题**上的做题状态。判题回写记在 user_profile 的
|
||
* `acm_problems_status.contest_problems`（judge/run.ts），公开题库那份记在 `problems`
|
||
* 下，两边互不干扰。
|
||
*
|
||
* 原来这两条路由一律下发空状态，于是比赛题目页的「状态」列永远是「未做」，赛后也不
|
||
* 恢复 —— 而库里其实一直记着。
|
||
*
|
||
* 不按「比赛结没结束」分档：这是学生自己的判题结果，赛中赛后都不泄露别人的任何信息
|
||
* （旧后端赛中不下发，纯粹是因为它整条路换了个 serializer，不是什么保密考虑）。
|
||
*/
|
||
async function contestProblemStatuses(userId: number | undefined) {
|
||
if (!userId) return {}
|
||
const [profile] = await db
|
||
.select({ status: schema.userProfile.acmProblemsStatus })
|
||
.from(schema.userProfile)
|
||
.where(eq(schema.userProfile.userId, userId))
|
||
.limit(1)
|
||
return asRecord(asRecord(profile?.status).contest_problems)
|
||
}
|
||
|
||
function myStatusOf(statuses: Record<string, unknown>, problemId: number) {
|
||
const status = asRecord(statuses[String(problemId)]).status
|
||
return typeof status === "number" ? status : null
|
||
}
|
||
|
||
async function contestProblemTags(problemIds: number[]) {
|
||
if (problemIds.length === 0) return new Map<number, string[]>()
|
||
const rows = await db
|
||
.select({
|
||
problemId: schema.problemTags.problemId,
|
||
name: schema.problemTag.name,
|
||
})
|
||
.from(schema.problemTags)
|
||
.innerJoin(schema.problemTag, eq(schema.problemTags.problemtagId, schema.problemTag.id))
|
||
.where(inArray(schema.problemTags.problemId, problemIds))
|
||
const map = new Map<number, string[]>()
|
||
for (const row of rows) map.set(row.problemId, [...(map.get(row.problemId) ?? []), row.name])
|
||
return map
|
||
}
|
||
|
||
contestRoutes.get(
|
||
"/contests/:id/problems",
|
||
optionalAuth,
|
||
requireContestAccess("problems"),
|
||
async (c) => {
|
||
const contest = c.get("contest")!
|
||
const rows = await db
|
||
.select({
|
||
problem: schema.problem,
|
||
user: schema.user,
|
||
realName: schema.userProfile.realName,
|
||
})
|
||
.from(schema.problem)
|
||
.innerJoin(schema.user, eq(schema.problem.createdById, schema.user.id))
|
||
.leftJoin(schema.userProfile, eq(schema.userProfile.userId, schema.user.id))
|
||
.where(and(eq(schema.problem.contestId, contest.id), eq(schema.problem.visible, true)))
|
||
.orderBy(asc(schema.problem.displayId))
|
||
const tags = await contestProblemTags(rows.map((row) => row.problem.id))
|
||
const allowed = contestDetailsAllowed(c.get("user"), contest)
|
||
const statuses = await contestProblemStatuses(c.get("user")?.id)
|
||
return success(
|
||
c,
|
||
rows.map(
|
||
({ problem, user, realName }) =>
|
||
({
|
||
id: problem.id,
|
||
_id: problem.displayId,
|
||
title: problem.title,
|
||
submissionNumber: allowed ? problem.submissionNumber : 0,
|
||
acceptedNumber: allowed ? problem.acceptedNumber : 0,
|
||
difficulty: allowed ? problem.difficulty : null,
|
||
createdBy: sampleUser(user, realName),
|
||
tags: tags.get(problem.id) ?? [],
|
||
contestId: contest.id,
|
||
allowFlowchart: problem.allowFlowchart,
|
||
showFlowchart: problem.showFlowchart,
|
||
hasAstRules: problem.astRules !== null,
|
||
myStatus: myStatusOf(statuses, problem.id),
|
||
}) satisfies ProblemListItem,
|
||
),
|
||
)
|
||
},
|
||
)
|
||
|
||
contestRoutes.get(
|
||
"/contests/:id/problems/:displayId",
|
||
optionalAuth,
|
||
requireContestAccess("problems"),
|
||
async (c) => {
|
||
const contest = c.get("contest")!
|
||
const [row] = await db
|
||
.select({
|
||
problem: schema.problem,
|
||
user: schema.user,
|
||
realName: schema.userProfile.realName,
|
||
})
|
||
.from(schema.problem)
|
||
.innerJoin(schema.user, eq(schema.problem.createdById, schema.user.id))
|
||
.leftJoin(schema.userProfile, eq(schema.userProfile.userId, schema.user.id))
|
||
.where(
|
||
and(
|
||
eq(schema.problem.contestId, contest.id),
|
||
eq(schema.problem.visible, true),
|
||
sql`lower(${schema.problem.displayId}) = lower(${c.req.param("displayId")})`,
|
||
),
|
||
)
|
||
.limit(1)
|
||
if (!row) return failure(c, 404, "problem-not-found", "Problem does not exist")
|
||
const tags = await contestProblemTags([row.problem.id])
|
||
const allowed = contestDetailsAllowed(c.get("user"), contest)
|
||
const statuses = await contestProblemStatuses(c.get("user")?.id)
|
||
return success(c, {
|
||
id: row.problem.id,
|
||
_id: row.problem.displayId,
|
||
title: row.problem.title,
|
||
description: row.problem.description,
|
||
inputDescription: row.problem.inputDescription,
|
||
outputDescription: row.problem.outputDescription,
|
||
samples: Array.isArray(row.problem.samples) ? row.problem.samples : [],
|
||
hint: row.problem.hint,
|
||
languages: row.problem.languages,
|
||
template: publicTemplates(row.problem.template),
|
||
createTime: row.problem.createTime,
|
||
lastUpdateTime: row.problem.lastUpdateTime,
|
||
timeLimit: row.problem.timeLimit,
|
||
memoryLimit: row.problem.memoryLimit,
|
||
difficulty: allowed ? row.problem.difficulty : null,
|
||
source: row.problem.source,
|
||
prompt: row.problem.prompt,
|
||
submissionNumber: allowed ? row.problem.submissionNumber : 0,
|
||
acceptedNumber: allowed ? row.problem.acceptedNumber : 0,
|
||
statisticInfo: allowed ? asRecord(row.problem.statisticInfo) : {},
|
||
contestId: contest.id,
|
||
tags: tags.get(row.problem.id) ?? [],
|
||
createdBy: sampleUser(row.user, row.realName),
|
||
myStatus: myStatusOf(statuses, row.problem.id),
|
||
// 比赛里不给 AI 提示（POST /ai/hint 见到比赛提交直接 403），这个数只喂那个按钮，恒 0
|
||
myFailedCount: 0,
|
||
allowFlowchart: row.problem.allowFlowchart,
|
||
showFlowchart: row.problem.showFlowchart,
|
||
mermaidCode: row.problem.allowFlowchart ? null : row.problem.mermaidCode,
|
||
flowchartData: row.problem.allowFlowchart ? null : asRecord(row.problem.flowchartData),
|
||
flowchartHint: row.problem.flowchartHint,
|
||
sqlConfig: row.problem.sqlConfig,
|
||
sqlDisplay: row.problem.sqlDisplay,
|
||
// 代码要求：只给渲染好的文案，规则原文不下发给学生
|
||
astRequirements: astRequirements(row.problem.astRules),
|
||
} satisfies ProblemDetail)
|
||
},
|
||
)
|
||
|
||
contestRoutes.get("/contests/:id/rank", optionalAuth, requireContestAccess("ranks"), async (c) => {
|
||
const contest = c.get("contest")!
|
||
const limit = queryInteger(c.req.query("limit"), 10, { min: 1, max: 250 })
|
||
const offset = queryInteger(c.req.query("offset"), 0, { min: 0 })
|
||
const where = and(
|
||
eq(schema.acmContestRank.contestId, contest.id),
|
||
inArray(schema.user.adminType, [...STUDENT_ROLES]),
|
||
eq(schema.user.isDisabled, false),
|
||
)
|
||
const [totalRows, rows] = await Promise.all([
|
||
db
|
||
.select({ value: count() })
|
||
.from(schema.acmContestRank)
|
||
.innerJoin(schema.user, eq(schema.acmContestRank.userId, schema.user.id))
|
||
.where(where),
|
||
db
|
||
.select({
|
||
rank: schema.acmContestRank,
|
||
user: schema.user,
|
||
realName: schema.userProfile.realName,
|
||
})
|
||
.from(schema.acmContestRank)
|
||
.innerJoin(schema.user, eq(schema.acmContestRank.userId, schema.user.id))
|
||
.leftJoin(schema.userProfile, eq(schema.userProfile.userId, schema.user.id))
|
||
.where(where)
|
||
// 末尾的 id 是给排序兜全序用的：同 AC 数同罚时前两列分不出先后，而这条列表是
|
||
// limit/offset 翻页的，行序不稳定就意味着同一个人在第 2 页出现两次、另一个人
|
||
// 从此消失。id 本身不参与名次，只保证同分的人每次都按同一个顺序排
|
||
.orderBy(
|
||
desc(schema.acmContestRank.acceptedNumber),
|
||
asc(schema.acmContestRank.totalTime),
|
||
asc(schema.acmContestRank.id),
|
||
)
|
||
.limit(limit)
|
||
.offset(offset),
|
||
])
|
||
const admin = isContestAdmin(c.get("user"), contest)
|
||
return success(c, {
|
||
results: rows.map(
|
||
({ rank, user, realName }) =>
|
||
({
|
||
id: rank.id,
|
||
// 唯一显式打开真名的地方，对齐旧后端 contest/serializers.py:84
|
||
// `UsernameSerializer(obj.user, need_real_name=self.is_contest_admin)`
|
||
user: sampleUser(user, realName, { includeRealName: admin }),
|
||
submissionNumber: rank.submissionNumber,
|
||
acceptedNumber: rank.acceptedNumber,
|
||
totalTime: rank.totalTime,
|
||
submissionInfo: rank.submissionInfo,
|
||
contestId: rank.contestId,
|
||
}) satisfies ContestRankItem,
|
||
),
|
||
total: totalRows[0]?.value ?? 0,
|
||
} satisfies ContestRank)
|
||
})
|