xuyueandClaude Opus 5.5
e7b95d211d
题目页重构之后按「功能对照 / 状态 / 结果页 / 布局与后端」四路审查了一遍，查出的问题一起修： 提交与换题 - 提交、画流程图途中换题：A 题格式化好的代码会盖掉 B 的草稿，A 判对了把 B 标成已解决、 弹 B 的点评、题单里跳回题单。现在每个请求回来先核对题目，轮询和推送回来的也核对提交编号 - 画着流程图换到不能画的题，语言退到题目的第一门、还被记成偏好；现在回到学生习惯的那门 - 强制点评评完点「继续 / 下一题」，学生之前在看「题目」页签的话会停在原题 - 离开题目页之后判题、流程图的 WebSocket 一直连着，现在闲 15 分钟断开 运行例子 - 输出开头的空格被削掉，打印菱形这类题对的代码也显示「没对上」 - C 的编译警告拼进了「你的输出」（后台生成测试点也会写进 .out） - Python 的语法错误（中文标点）被说成「下标有没有越界、除数是不是 0」 - 比赛里仍然把空格画成「·」、把不同的地方标红 入口与协作 - 比赛里不给「课堂统计」、不绑协作：房间和统计都按题号找，比赛题号和公开题撞号 - 「看他交过什么」按整名匹配，不再混进学号相近的同学 - 协作中点上下文条、相似题、下一题开新标签，协作不断 - 题单入口给管理员的「⋯」里留「本题提交」 结果与题面 - 「去自己输入拿 51 这些数试试」取到了题面 HTML 里的颜色值；「题目原话」露出 " - 流程图 A 级的学生标题下还写着「还没交过」 - 「我的提交」上方补回「答案错误 × 3」这样的计数 - 流程图历次评分能点开看那一版的图；读分数失败不再说「还没交过流程图」；手机上能看流程图点评 - 「结果」页签有新结果没看时加粗上色，看过就恢复 - 空画布拖进第一个节点画布会跳一下；画布底下空着一条 - 比赛没开始写成「已结束」、倒计时超过一个月算错；分隔条拖到头工具栏被挤坏；题单里的题目页有备案页脚 - 流程图历次分数只读需要的几列（一个学生一道题 23 次提交：96 kB → 2 kB） - 比赛密码、比赛没开始等几条学生看得到的英文报错换成中文 设计文档照实际做法更新了第 5.5、5.6、6、8、9、10、11 节。 Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
376 lines
15 KiB
TypeScript
376 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", "比赛不存在")
|
||
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", "比赛不存在")
|
||
const parsed = await parseBody(c, contestPasswordRequestSchema, "请输入比赛密码")
|
||
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", "比赛密码不对，或者已经过期了，请重新输入")
|
||
}
|
||
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", "比赛不存在")
|
||
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", "题目不存在")
|
||
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)
|
||
})
|