fix(release): 发布1.4.5并加固登录与灵动岛体验

登录连续五次失败封禁五分钟,修复两端错误提示;教师导入逐人生成随机密码并提供一次性清单。统一自定义岛外观与控件,修复圆角配置和全天课表对齐,临近下课显示课程旁秒数徽标;客户端更新改为云端统一下发。同步发布版本、帮助文档及隔离回归。
This commit is contained in:
LoveChengke committed 2026-11-08 09:55:33 +08:00
1 parent 9351203deb
commit 0b57e926bd
52 files changed
+722 -797

No files matched your search

+1 -1
View File
@@ -23,7 +23,7 @@ services:
context: ..
dockerfile: deploy/Dockerfile
target: runtime
image: classhelper-server:${APP_VERSION:-1.4.4}
image: classhelper-server:${APP_VERSION:-1.4.5}
restart: unless-stopped
environment:
NODE_ENV: production
+1 -1
View File
@@ -60,7 +60,7 @@ services:
context: ..
dockerfile: deploy/Dockerfile
target: runtime
image: classhelper-server:${APP_VERSION:-1.4.4}
image: classhelper-server:${APP_VERSION:-1.4.5}
restart: unless-stopped
environment:
NODE_ENV: production
+1 -1
View File
@@ -1,6 +1,6 @@
{
"name": "classhelper-server-runtime",
"version": "1.4.4",
"version": "1.4.5",
"private": true,
"type": "module",
"description": "ClassHelper 服务端运行时(安装包 / 容器内置)",
+1 -1
View File
@@ -96,6 +96,6 @@ beUI 的组件本身是 React,用不到这里,但它的动效语言与框架
| 灵动岛 | 尺寸、字号、主题色、视觉风格、停靠、边距、空闲细缝(详见[灵动岛](island.md)) |
| 提醒 | 本机课程等提醒开关与行为 |
| 账号 | 当前班级信息、退出登录 |
| 关于 | 版本 / Electron / Chromium / Node、诊断信息、检查更新、鸣谢 |
| 关于 | 版本 / Electron / Chromium / Node、诊断信息、云端下发更新的进度、鸣谢 |
`/settings` 会自动跳到「通用」。设置页的改动会**立刻生效并写进本机配置**,重启后仍保留。
+1 -1
View File
@@ -16,7 +16,7 @@ description: 表格预览、名单与成绩校验,以及完整离线档案导
- 学生成绩按学号匹配,姓名兜底要求同班唯一;转出学生不参与匹配,重复记录和写入模式由服务校验。
- 学生模板使用学号、姓名、班级、性别、家长电话,无密码;学号 1–32 位字母/数字/._-,在 Student 表查重。
- 教师模板使用工号、姓名、手机号、初始密码、角色;学生/教师名单导入仍要求管理员和导入权限。
- 教师模板使用工号、姓名、手机号、角色;每个新建教师分别生成随机初始密码,导入结果提供一次性查看和 CSV 下载,关闭前请保存分发。重复导入已有教师不修改密码,旧表格中的密码列不再用于设置密码。任课关系导入中新建的教师采用相同规则;学生/教师名单导入仍要求管理员和导入权限。
- 成绩表格导入当前先要求管理员或本班班主任,再校验每行科目任课关系;科任老师的单条/批量成绩写入权限不代表能走表格导入。
- 任课关系导入用于既有班级、科目和教师的对应关系,不把档案中的 TeacherName 当账号授权。
+5 -5
View File
@@ -37,7 +37,7 @@ description: 经典提醒、自定义常驻方案、课程与课件传输。
“设置 → 灵动岛 → 自定义 → 编辑岛内组件”进入主窗口设置页。
页面上方排列当前组件,右上角选择配置方案;刷新图标重置当前方案,加号新建方案,文件夹菜单提供方案设置、复制、删除及 JSON 导入导出。
下方组件库常驻显示文本、分割线、课程表、日期、时钟、天气简报、倒计时和组合容器,并保留班级通知、作业和叫人组件。
下方组件库常驻显示文本、分割线、课程表、日期、时钟、天气简报、倒计时和组合容器。通知、作业和叫人通过岛内铃铛及共用消息面板展示,组件库不再提供这些消息选项;已有方案中的消息节点仍兼容。
从组件库拖入上方的行或容器以添加,拖动已有组件调整顺序或跨行移动;也可点击组件库添加到选中的容器或当前行。
分别编辑常态 rows 与无消息展开 expandedRows,点选组件打开内容、外观、尺寸与隐藏条件设置;行可以新增、排序、设为主要行或删除。
“进入编辑模式”切换为实际内容预览,支持预览缩放;退出后回到组件标签排列。轮播和滚动容器在编辑时展示全部子组件,便于选择和排列。
@@ -50,7 +50,7 @@ description: 经典提醒、自定义常驻方案、课程与课件传输。
## 外观、位置与输入
经典模式可调宽高、字号、主题色、黑色/半透明/渐变、停靠与边距;自定义内容根据实际测量适配工作区。
自定义方案可配置缩放、圆角、颜色和行间距,默认值与范围在 shared/island-layout.ts。
自定义方案可配置缩放、圆角、颜色和行间距,默认值与范围在 shared/island-layout.ts。外观页的圆角滑块同步修改当前自定义方案的常态圆角,与编辑器设置一致。
左右边距只在左/右停靠时生效,居中锚点仍在屏幕中线。
触摸屏自动进入触摸模式,保留触摸命中和失焦宽限;鼠标模式按光标控制输入穿透。
自定义常驻内容支持鼠标避让淡化及反转,交互入口、展开/编辑和触摸操作按实现暂停避让。
@@ -65,9 +65,9 @@ description: 经典提醒、自定义常驻方案、课程与课件传输。
自定义常驻岛的「课程表」组件可选「当前时间点 / 下一节课 / 今日时间点」:
「今日时间点」显示当天全部时间点,只有当前项展开显示起止时间,其余折叠只显示课程名;
课间休息与「默认隐藏」的上课时间点折叠时完全隐藏,轮到它们时才展开;分割线显示一条竖线,行动不显示。
课中课程表不再常驻显示倒计时,只在最后一分钟由既有的「下课提醒」页显示「距下课还剩」;
倒计时阈值沿用本机提醒设置(默认 60 秒)。没有时间点数据时退回按课表条目显示课程。
经典 fixed 岛的课中提醒条保持原有倒计时行为。
临近下课时,当前课程名右侧显示蓝色圆形秒数徽标,例如剩余一秒显示 `-1`,不显示“即将下课”遮罩,也不替换自定义岛的常态组件。
倒计时阈值沿用本机提醒设置(默认 60 秒),关闭即将下课倒数后不显示徽标。没有时间点数据时退回按课表条目显示课程。
经典 fixed 岛的临近下课提醒也使用课程名右侧的秒数徽标,其余上下课提醒保留。
课件接收时显示文件名、类型、教师、字节和进度,覆盖当前固定/自定义内容;完成后校验 SHA256 并回执。
客户端不会自动执行收到的文件,见[课件](courseware.md)。
+2 -2
View File
@@ -308,7 +308,7 @@ pnpm --filter @classhelper/server start # 或 node packages/server/dist/ind
## 五、环境变量清单
| 变量 | 默认 | 说明 |
| --------------------------------------------------- | ---------------------- | ----------------------------------------------------------- |
| --------------------------------------------------- | ---------------------- | ------------------------------------------------------------------------------------------------------------- |
| `NODE_ENV` | `development` | `production` 会启用生产校验、HSTS、更严的限流 |
| `HOST` / `PORT` | `0.0.0.0` / `4000` | 监听地址与端口 |
| `DATABASE_PROVIDER` | `sqlite` | `sqlite` 或 `mysql` |
@@ -318,7 +318,7 @@ pnpm --filter @classhelper/server start # 或 node packages/server/dist/ind
| `JWT_EXPIRES_IN` | `7d` | 令牌有效期 |
| `CORS_ORIGIN` | `*` | 允许来源,多个用逗号分隔;生产建议写具体域名 |
| `TRUST_PROXY` | `false` | 反向代理层数(Nginx 填 `1`),影响限流与日志中的真实 IP |
| `RATE_LIMIT_ENABLED` | `true` | 通用限流(生产 600 次/5 分钟)+ 登录限流(20 次/10 分钟) |
| `RATE_LIMIT_ENABLED` | `true` | 通用限流(生产 600 次/5 分钟);同一来源 IP 连续五次登录失败后封禁 5 分钟,成功登录清零,两种登录入口共用计数 |
| `STARTUP_DB_CHECK` | `true` | 启动校验数据库;生产不可用时直接退出 |
| `PID_FILE` | — | PID 文件路径(安装包启停脚本依赖),相对 `server` 根 |
| `WEB_DIST_DIR` | 自动探测 | Web 管理端产物目录(`../web-admin/dist` 或 `./web`) |
+6 -13
View File
@@ -18,17 +18,11 @@ description: 检查更新与各形态的升级步骤、Linux 的升级回滚链
## 检查更新
| 端 | 入口 | 检查路径 |
| ------------------- | --------------------------------------------------------------- | ------------------------------------------------ |
| ------------------- | ---------------------------------------------- | ------------------------------------------------ |
| 服务端 / Web 管理端 | 顶栏用户菜单 →「检查更新」 | 浏览器 → 服务端 `GET /api/update/check` → GitHub |
| 桌面客户端 | 启动后自动一次(延迟 5 秒)+「设置 → 关于」里的「检查更新」按钮 | 主进程 → GitHub(不经后端) |
| 桌面客户端 | 管理端「客户端管理」登记安装包并向班级下发更新 | 客户端只从当前服务端领取更新策略与安装包 |
两端的路径不同是**被约束逼出来的**:
- **Web 端不能直连 GitHub**。服务端下发的 CSP 里 `connect-src` 只放行 `'self'` 与 WebSocket,
浏览器发往 `api.github.com` 的请求会直接被拦掉。走服务端转发还有个好处:所有管理员共享同一份缓存
(GitHub 匿名限流是 60 次/小时/IP)。
- **客户端在主进程做**。渲染进程的 CSP 与导航防线是安全模型里最要紧的一层,
不让它去连外部域名、解析外部 JSON。
Web 管理端经服务端查询 GitHub Release。客户端不再主动检查 GitHub,也不提供手动检查入口;更新由管理端统一下发,仍校验 SHA256 并遵循本机自动更新开关和服务端策略。
### "查不到"是设计内的结果
@@ -39,12 +33,11 @@ description: 检查更新与各形态的升级步骤、Linux 的升级回滚链
失败结果同样进缓存 —— 否则断网时每点一次按钮都要白等一个超时。
| 细节 | 说明 |
| ---------- | ----------------------------------------------------------------------------------------------------- |
| 缓存 | 两端各缓存 30 分钟;`?force=1` 绕过服务端缓存,但**仅管理员生效**(否则任意登录用户都能刷爆匿名限流) |
| ---- | ----------------------------------------------------------------------------------------------------- |
| 缓存 | 服务端缓存 30 分钟;`?force=1` 绕过服务端缓存,但**仅管理员生效**(否则任意登录用户都能刷爆匿名限流) |
| 权限 | 任何已登录用户都能查(信息来自公开仓库);`force` 除外 |
| 只提示一次 | 客户端启动检查发现新版才推提示;点「忽略此版本」记进配置,同一版本不再提示 |
更新**只提示,不自动下载、不自动安装**。安装包仍由人从 [Releases](https://github.com/LoveChengke/classhelper/releases)
服务端的更新检查只提示,不自动安装。管理员可从 [Releases](https://github.com/LoveChengke/classhelper/releases)
页面取,可用 `SHA256SUMS-<版本>.txt` 核对。
## 升级步骤
+3 -1
View File
@@ -1,6 +1,6 @@
{
"name": "class-helper",
"version": "1.4.4",
"version": "1.4.5",
"private": true,
"description": "ClassHelper - 班级信息管理系统(Web 管理端 + 后端服务 + 桌面客户端)",
"packageManager": "pnpm@11.8.0",
@@ -38,6 +38,8 @@
"verify:update-installer": "node scripts/verify-update-installer.mjs",
"verify:client-update:real": "node scripts/verify-client-update-real.mjs --real-install",
"verify:review-client": "node scripts/verify-review-client.mjs",
"verify:panel-security": "node scripts/verify-panel-security.mjs",
"verify:island-editor": "node scripts/verify-island-editor.mjs",
"verify:review-api": "node scripts/verify-e2e-isolated.mjs --review-api",
"verify:clients-api": "node scripts/verify-e2e-isolated.mjs --clients-api",
"verify:client-migrations": "node scripts/verify-client-migrations.mjs",
+1 -1
View File
@@ -1,6 +1,6 @@
{
"name": "@classhelper/desktop-client",
"version": "1.4.4",
"version": "1.4.5",
"private": true,
"description": "ClassHelper EXE 客户端(Electron + Vue 3 + Element Plus + Socket.IO + IndexedDB 离线缓存)",
"author": "Class Helper",
+2 -2
View File
@@ -84,8 +84,8 @@ function launchSmoke(extraEnv) {
child.kill();
resolve(124);
},
// 快速套件已包含本地 HTTP、校验下载和布局编辑;保留冷启动余量,单项断言不放宽。
mode === 'visual' ? 360_000 : 90_000,
// 快速套件包含两种布局的完整上下课时序、本地下载和编辑;总时限保留冷启动余量。
mode === 'visual' ? 360_000 : 120_000,
);
child.once('exit', (code) => {
clearTimeout(deadline);
@@ -37,8 +37,8 @@ const current = computed(() => today.value.find((s) => s.id === status.value.cur
const next = computed(() => today.value.find((s) => s.id === status.value.next?.scheduleId));
function timeAt(time: string) {
const d = new Date(props.now);
const [h, m] = time.split(':').map(Number);
d.setHours(h!, m!, 0, 0);
const [h, m, s = 0] = time.split(':').map(Number);
d.setHours(h!, m!, s, 0);
return d.getTime();
}
/**
@@ -106,6 +106,7 @@ const remaining = computed(() =>
currentLesson.value ? Math.max(0, Math.ceil((timeAt(currentLesson.value.endTime) - props.now) / 1000)) : 0,
);
const hidden = computed(
// 临近下课仍使用真实时间点,不因提醒切换而替换课程组件。
() =>
!props.editing &&
((['notification', 'homework', 'call'].includes(props.node.kind) &&
@@ -256,6 +257,13 @@ const style = computed<CSSProperties>(() => {
:class="{ current: p.id === currentPoint?.id, break: p.timeType === 'BREAK' }"
>
<strong>{{ p.courseName || p.name || '—' }}</strong>
<span
v-if="p.id === currentLesson?.id && state.lessonReminder?.kind === 'ending' && remaining > 0"
class="lesson-ending-badge"
:aria-label="`距下课${remaining}秒`"
>
-{{ remaining }}
</span>
<small v-if="p.id === currentPoint?.id && node.settings.showPeriod" class="lesson-time">
{{ p.startTime }}–{{ p.endTime }}
</small>
@@ -352,8 +360,11 @@ const style = computed<CSSProperties>(() => {
transform-origin: left;
transition: transform 1s linear;
}
.schedule > .lesson-line + .lesson-line {
margin-top: 8px;
.schedule {
display: flex;
flex-direction: column;
align-items: center;
gap: 8px;
}
.separator > span {
display: block;
@@ -441,3 +452,5 @@ strong,
}
}
</style>
<style src="./lesson-ending.css"></style>
<style src="./lesson-ending.css"></style>
@@ -27,7 +27,10 @@ const props = defineProps<{
}>();
const scheme = computed(() => props.settings.schemes.find((s) => s.id === props.settings.activeSchemeId)!);
const expanded = computed(() => props.state.mode === 'expanded');
const lesson = computed(() => props.state.lessonReminder ?? null);
// 即将下课只在当前课程旁显示秒数,保留常驻组件与消息入口。
const lesson = computed(() =>
props.state.lessonReminder?.kind === 'ending' ? null : (props.state.lessonReminder ?? null),
);
const lastLesson = ref<IslandLessonReminder | null>(null);
watch(
lesson,
@@ -283,7 +286,15 @@ watch(
{ deep: true, flush: 'post' },
);
watch(
[fit, motion, expanded, lesson, () => props.appearance.radius, () => props.appearance.speed],
[
fit,
motion,
expanded,
lesson,
() => scheme.value.radius,
() => props.appearance.radius,
() => props.appearance.speed,
],
() => {
animate();
trackHit();
@@ -10,7 +10,7 @@ const props = defineProps<{
}>();
const root = ref<HTMLElement>();
const width = ref(480);
const mask = computed(() => props.now < props.reminder.maskUntil);
const mask = computed(() => props.reminder.kind !== 'ending' && props.now < props.reminder.maskUntil);
const title = computed(
() =>
({
@@ -140,15 +140,14 @@ onUnmounted(() => {
aria-live="polite"
>
<div class="ci-lesson-info">
<span
v-if="reminder.kind === 'prepare' || reminder.kind === 'ending' || reminder.kind === 'in-class'"
class="ci-countdown"
>
<span v-if="reminder.kind === 'prepare' || reminder.kind === 'in-class'" class="ci-countdown">
{{ reminder.kind === 'prepare' ? '距上课还剩' : '距下课还剩' }}
<strong>{{ leftSeconds }}</strong>
秒
</span>
<span v-else class="ci-countdown">{{ reminder.kind === 'on-class' ? '开始上课' : '课间休息' }}</span>
<span v-else-if="reminder.kind !== 'ending'" class="ci-countdown">
{{ reminder.kind === 'on-class' ? '开始上课' : '课间休息' }}
</span>
<span class="ci-lesson-course">
<span>
{{
@@ -158,6 +157,13 @@ onUnmounted(() => {
}}
</span>
<strong>{{ course || '今日课程已结束' }}</strong>
<span
v-if="reminder.kind === 'ending'"
class="lesson-ending-badge"
:aria-label="`距下课${leftSeconds}秒`"
>
-{{ leftSeconds }}
</span>
<small v-if="course">{{ time }}</small>
</span>
</div>
@@ -309,3 +315,4 @@ onUnmounted(() => {
transition: transform 50ms linear;
}
</style>
<style src="./lesson-ending.css"></style>
@@ -0,0 +1,16 @@
/* 两种岛共用临近下课徽标;固定正圆,数字使用等宽字形。 */
.lesson-ending-badge {
display: inline-flex;
align-items: center;
justify-content: center;
flex: 0 0 auto;
width: 30px;
height: 30px;
border-radius: 50%;
color: #fff;
background: #0a84ff;
font-size: 12px;
font-weight: 600;
font-variant-numeric: tabular-nums;
line-height: 1;
}
@@ -19,8 +19,6 @@ export const IPC_CHANNELS = {
clearConfig: 'classhelper:config:clear',
appInfo: 'classhelper:app:info',
openExternal: 'classhelper:shell:open-external',
updateCheck: 'classhelper:update:check',
updateIgnore: 'classhelper:update:ignore',
getAutoLaunch: 'classhelper:app:get-autolaunch',
setAutoLaunch: 'classhelper:app:set-autolaunch',
openLogDir: 'classhelper:app:open-log-dir',
@@ -28,6 +26,3 @@ export const IPC_CHANNELS = {
clientStatus: 'classhelper:client:status',
clientBeatNow: 'classhelper:client:beat-now',
} as const;
/** 主进程 → 渲染进程的单向推送:有可用更新(同理,供 preload 与主进程共用) */
export const UPDATE_AVAILABLE_CHANNEL = 'classhelper:update:available';
+1 -1
View File
@@ -43,7 +43,7 @@ interface PersistedConfig {
theme?: 'light' | 'dark';
/** 主侧边栏是否折叠(向后兼容:旧配置没有该字段视为展开) */
sidebarCollapsed?: boolean;
/** 用户选择「忽略此版本」的版本号(向后兼容:旧配置没有该字段视为没忽略过任何版本) */
/** 旧版主动更新检查的兼容字段;统一云端下发更新后不再参与更新决策。 */
ignoredUpdateVersion?: string;
/** 本机设备标识(向后兼容:旧配置没有该字段时首次读取生成并落盘,之后永不变) */
deviceKey?: string;
@@ -10,7 +10,6 @@ import { island, registerIslandIpc } from './island.js';
import { logger } from './logger.js';
import { runSmokeTest } from './smoke.js';
import { createTray, destroyTray, isTrayReady } from './tray.js';
import { scheduleStartupUpdateCheck } from './update.js';
// 主进程由 esbuild 打包为 CommonJS,因此这里可以直接使用 __dirname
// (dist/main/index.js -> dist/preload/index.js 与 dist/renderer/index.html)
@@ -259,9 +258,6 @@ if (!gotLock) {
logger.warn(`系统托盘初始化失败(不影响主功能):${error instanceof Error ? error.message : error}`);
}
// 启动后自动查一次更新(延迟几秒,不跟首屏抢带宽);冒烟模式下自动跳过,见 main/update.ts
scheduleStartupUpdateCheck(() => mainWindow);
// 服务端统一下发:定时上报本机状态并领取「待执行命令 / 统一更新」(冒烟默认不上报)
startClientAgent();
-17
View File
@@ -9,12 +9,10 @@ import { island } from './island.js';
import { getIslandWeather } from './island-weather.js';
import { getUpdateProgress } from './auto-update.js';
import { app, BrowserWindow, ipcMain, shell } from 'electron';
import type { UpdateInfo } from '@classhelper/shared';
import { IPC_CHANNELS } from './channels.js';
import { beatNow, getClientAgentStatus } from './client-agent.js';
import { clearConfig, getConfig, getConfigPath, saveConfig } from './config.js';
import { logger } from './logger.js';
import { checkForUpdates, ignoreUpdateVersion } from './update.js';
import type { DesktopAppInfo, DesktopStoredConfig } from '../types/desktop.js';
// 通道名定义搬到了叶子模块 `channels.ts`(原因见那里的注释:preload 在沙箱里不能碰 node 内建模块);
@@ -65,21 +63,6 @@ export function registerIpcHandlers(): void {
return true;
});
/**
* 检查更新(走主进程直连 GitHub,见 main/update.ts 的说明)。
*
* `force` 为 true 时绕过主进程缓存 —— 对应「关于」页里用户主动点的那次检查;
* 启动自动检查一律用缓存(避免同一分钟内重复请求打满匿名限流)。
*/
ipcMain.handle(IPC_CHANNELS.updateCheck, (_event, force?: boolean): Promise<UpdateInfo> => {
return checkForUpdates(force === true);
});
/** 忽略某个版本的更新提示(记入 config.json,启动自动检查不再提示它) */
ipcMain.handle(IPC_CHANNELS.updateIgnore, (_event, version: string): void => {
if (typeof version === 'string') ignoreUpdateVersion(version);
});
/** 开机自启:读的是系统登录项,不是配置文件里的值(两者可能被外部改过) */
ipcMain.handle(IPC_CHANNELS.getAutoLaunch, (): boolean => {
try {
+5 -1
View File
@@ -171,6 +171,7 @@ class IslandController {
private lessonTimer: ReturnType<typeof setInterval> | null = null;
private lessonTestTime: number | null = null;
private get lessonShowing(): boolean {
if (this.customLayout && this.lessonCue?.kind === 'ending') return false;
return Boolean(
this.lessonCue &&
!this.editingLayout &&
@@ -649,7 +650,10 @@ class IslandController {
return {
...this.state,
coursewareTransfer: this.coursewareShowing ? this.state.coursewareTransfer : null,
lessonReminder: this.lessonShowing ? this.lessonCue : null,
lessonReminder:
this.lessonShowing || (this.customLayout && this.lessonCue?.kind === 'ending')
? this.lessonCue
: null,
queued: [...this.state.queued],
};
}
@@ -527,7 +527,7 @@ export async function verifyResidentSmoke(
await pause(700);
return Math.abs(immediate - opacity) < 0.01 && Math.abs(after - opacity) < 0.01;
});
await check('两种布局均弹出ClassIsland课前/上下课提醒,倒计时与右侧时间正确且不写入通知队列', async () => {
await check('两种布局的上下课提醒、课程旁下课倒数与右侧时间正确且不写入通知队列', async () => {
const capture = process.env.ISLAND_MOTION_CAPTURE === '1' && process.env.ELECTRON_SMOKE_MODE === 'visual';
const recorded: Array<{ at: number; image: Electron.NativeImage }> = [];
const start = Date.now();
@@ -642,17 +642,33 @@ export async function verifyResidentSmoke(
throw new Error('自动倒计时未切到本节下课');
}
if (layout === 'custom') {
saveConfig({ islandLayout: { ...fixture, layout } });
const endingLayout = JSON.parse(JSON.stringify(fixture));
endingLayout.schemes[0].rows[0].nodes = [islandNode('schedule', 'lesson-ending-course')];
saveConfig({ islandLayout: endingLayout });
island.syncCustomLayout();
}
await setTime(9, 44);
await pause(700);
await pause(1100);
if (island.getState().lessonReminder?.kind !== 'ending')
throw new Error(layout + '下课倒数状态错误:' + JSON.stringify(island.getState().lessonReminder));
const ending = await win.webContents.executeJavaScript(
`document.querySelector('${layout === 'custom' ? '.resident-lesson-page' : '.ci-fixed-lesson'}')?.textContent.includes('距下课还剩')`,
`(() => {
const root=document.querySelector('${layout === 'custom' ? '.resident-compact' : '.ci-fixed-lesson'}');
const badge=root?.querySelector('.lesson-ending-badge');
const course=root?.querySelector('${layout === 'custom' ? '.lesson-line.current strong' : '.ci-lesson-course strong'}');
const rect=badge?.getBoundingClientRect(),name=course?.getBoundingClientRect();
return Boolean(badge?.textContent.trim()==='-60'&&rect&&name&&rect.left>=name.right&&Math.abs(rect.width-rect.height)<1&&!root?.querySelector('.ci-mask-active'));
})()`,
);
if (!ending) throw new Error(layout + '下课倒数未渲染');
await setTime(9, 44, 59);
await pause(1100);
if (
!(await win.webContents.executeJavaScript(
`document.querySelector('${layout === 'custom' ? '.resident-compact' : '.ci-fixed-lesson'} .lesson-ending-badge')?.textContent.trim()==='-1'`,
))
)
throw new Error(layout + '最后一秒徽标错误');
await shot('lesson-ending-' + layout);
await setTime(9, 45);
island.setClassState({ inClass: false });
-41
View File
@@ -17,7 +17,6 @@ import {
ISLAND_URGENT_SIZE,
} from './island.js';
import { destroyTray, getTrayState, isTrayReady } from './tray.js';
import { checkForUpdates, wasStartupCheckSkipped } from './update.js';
interface SmokeResult {
name: string;
@@ -4478,46 +4477,6 @@ export async function runSmokeTest(win: BrowserWindow): Promise<void> {
);
record('关于页渲染(应用信息/诊断信息/鸣谢)', Boolean(aboutPage?.ok), String(aboutPage?.detail ?? ''));
// 更新检查(新功能回归):主进程直连 GitHub 取最新 Release。
//
// **刻意不断言"一定有新版本"**:那会把冒烟绑死在外网可达上,而教室机器常常没有外网
// (`ok=false` 是设计内的降级结果,不是失败)。因此两种结果都算通过,验的是:
// 结构完整、失败时有可读原因、以及缓存真的生效。
const updateFirst = await checkForUpdates(true);
const isVersionLike = (value: unknown): boolean => typeof value === 'string' && /^\d/.test(value);
const updateShapeOk =
isVersionLike(updateFirst.currentVersion) &&
typeof updateFirst.ok === 'boolean' &&
typeof updateFirst.hasUpdate === 'boolean' &&
(updateFirst.ok
? isVersionLike(updateFirst.latestVersion) &&
Array.isArray(updateFirst.assets) &&
/^https:\/\//.test(updateFirst.releaseUrl) &&
updateFirst.error === null
: typeof updateFirst.error === 'string' && updateFirst.error.length > 0);
record(
'更新检查返回结构正确(无外网时降级为 ok=false 且带原因)',
updateShapeOk,
`ok=${updateFirst.ok} 本机=${updateFirst.currentVersion} 最新=${updateFirst.latestVersion ?? '-'} ` +
`有新版本=${updateFirst.hasUpdate} 附件=${updateFirst.assets.length}` +
`${updateFirst.error ? ` 原因=${updateFirst.error}` : ''}`,
);
// 缓存:紧接着再查一次(不传 force)应命中缓存 —— checkedAt 不变即说明没有二次请求
const updateSecond = await checkForUpdates();
record(
'更新检查结果带缓存(不重复请求 GitHub)',
updateSecond.checkedAt === updateFirst.checkedAt,
`两次 checkedAt 相同=${updateSecond.checkedAt === updateFirst.checkedAt}`,
);
// 启动自动检查在冒烟模式下必须被跳过,否则每次验证都会产生一次真实网络请求与提示条
record(
'冒烟模式下跳过启动自动检查(验证不依赖外网)',
wasStartupCheckSkipped(),
`skipped=${wasStartupCheckSkipped()}`,
);
// 未读红点必须挂在"通知"图标右上方(用户反馈:原来挂在文字后面,位置不对)
const readBadgeGeometry = async (): Promise<{
ok: boolean;
-216
View File
@@ -1,216 +0,0 @@
import { app, type BrowserWindow } from 'electron';
import {
GITHUB_RELEASES_LATEST_API,
GITHUB_RELEASES_PAGE,
UPDATE_CHECK_CACHE_TTL_MS,
UPDATE_CHECK_TIMEOUT_MS,
UPDATE_CHECK_USER_AGENT,
isNewerVersion,
normalizeVersion,
type UpdateAssetDto,
type UpdateInfo,
} from '@classhelper/shared';
import { UPDATE_AVAILABLE_CHANNEL } from './channels.js';
import { getConfig, saveConfig } from './config.js';
import { logger } from './logger.js';
/**
* 更新检查(桌面客户端)。
*
* **为什么在主进程做**:渲染进程通过 preload 能拿到 `getConfig()` 的明文 token(代表全班身份),
* 它的 CSP 与导航防线是整个安全模型里最要紧的一层;让它额外去连一个外部域名、
* 解析外部 JSON,等于把"外部数据"请进最有价值的那一侧。主进程本来就在做网络与文件,
* 放这里也顺带复用 Node 的 fetch(无需额外依赖)。
*
* 与 Web 管理端的差别:Web 端受服务端 CSP 的 `connect-src` 限制,只能走 `/api/update/check` 转发;
* 客户端没有这个限制,按用户选择**直连 GitHub**。两边归一化出的 `UpdateInfo` 结构一致。
*/
/** 主进程 → 渲染进程:发现新版本(渲染进程据此弹一次性提示);定义在叶子模块 `channels.ts` */
export { UPDATE_AVAILABLE_CHANNEL };
/** 启动后多久自动查一次:等窗口与登录流程就绪,也不跟首屏请求抢带宽 */
const STARTUP_DELAY_MS = 5_000;
interface GithubReleasePayload {
tag_name?: unknown;
name?: unknown;
published_at?: unknown;
body?: unknown;
html_url?: unknown;
assets?: unknown;
}
let cache: { at: number; info: UpdateInfo } | null = null;
let startupTimer: ReturnType<typeof setTimeout> | null = null;
/** 冒烟断言用:启动自动检查是否被跳过(冒烟模式下必须是 true) */
let startupCheckSkipped = false;
/** 失败的统一出口:结构完整,界面不必做 null 判断 */
function failure(error: string): UpdateInfo {
return {
ok: false,
error,
currentVersion: app.getVersion(),
latestVersion: null,
hasUpdate: false,
releaseUrl: GITHUB_RELEASES_PAGE,
releaseName: null,
publishedAt: null,
notes: null,
assets: [],
checkedAt: new Date().toISOString(),
};
}
function toAssets(raw: unknown): UpdateAssetDto[] {
if (!Array.isArray(raw)) return [];
return raw
.map((item) => item as { name?: unknown; browser_download_url?: unknown; size?: unknown })
.filter(
(item): item is { name: string; browser_download_url: string; size?: unknown } =>
typeof item.name === 'string' && typeof item.browser_download_url === 'string',
)
.map((item) => ({
name: item.name,
downloadUrl: item.browser_download_url,
size: typeof item.size === 'number' && Number.isFinite(item.size) ? item.size : 0,
}));
}
function toInfo(payload: GithubReleasePayload, currentVersion: string): UpdateInfo {
const latestVersion = normalizeVersion(typeof payload.tag_name === 'string' ? payload.tag_name : '');
if (!latestVersion) {
logger.warn('更新检查:GitHub 返回的 Release 里没有可识别的 tag_name');
return failure('GitHub 返回的版本号无法识别');
}
return {
ok: true,
error: null,
currentVersion,
latestVersion,
hasUpdate: isNewerVersion(currentVersion, latestVersion),
releaseUrl:
typeof payload.html_url === 'string' && payload.html_url ? payload.html_url : GITHUB_RELEASES_PAGE,
releaseName: typeof payload.name === 'string' ? payload.name : null,
publishedAt: typeof payload.published_at === 'string' ? payload.published_at : null,
notes: typeof payload.body === 'string' ? payload.body : null,
assets: toAssets(payload.assets),
checkedAt: new Date().toISOString(),
};
}
/** 把各种失败翻译成一句用户能看懂的话(教室里最常见的就是"这台机器没有外网") */
function describeFailure(error: unknown): string {
const message = error instanceof Error ? error.message : String(error);
if (error instanceof Error && error.name === 'TimeoutError') {
return `连接 GitHub 超时(${UPDATE_CHECK_TIMEOUT_MS / 1000} 秒),本机可能没有外网`;
}
if (/fetch failed|ENOTFOUND|ECONNREFUSED|EAI_AGAIN|ETIMEDOUT|certificate|net::/i.test(message)) {
return '无法连接 GitHub,本机可能没有外网';
}
return `检查更新失败:${message}`;
}
/**
* 检查 GitHub 上有没有比本机新的版本(结果带缓存)。
*
* 缓存的意义:匿名调用 GitHub API 的限流是 60 次/小时/IP,而「关于」页的按钮可以随便点。
* 失败结果同样进缓存 —— 否则离线时每点一次都要白等一个超时。
*/
export async function checkForUpdates(force = false): Promise<UpdateInfo> {
const currentVersion = app.getVersion();
const now = Date.now();
if (!force && cache && now - cache.at < UPDATE_CHECK_CACHE_TTL_MS) {
return cache.info;
}
let info: UpdateInfo;
try {
const response = await fetch(GITHUB_RELEASES_LATEST_API, {
headers: {
// GitHub API 强制要求 User-Agent,不带会直接 403
'User-Agent': UPDATE_CHECK_USER_AGENT,
Accept: 'application/vnd.github+json',
},
signal: AbortSignal.timeout(UPDATE_CHECK_TIMEOUT_MS),
});
if (!response.ok) {
info =
response.status === 403 || response.status === 429
? failure('GitHub 暂时拒绝了请求(匿名查询次数过多),请过一会儿再试')
: failure(`GitHub 返回 HTTP ${response.status}`);
logger.warn(`更新检查失败:HTTP ${response.status}(本机版本 ${currentVersion})`);
} else {
info = toInfo((await response.json()) as GithubReleasePayload, currentVersion);
logger.info(
`更新检查:本机 ${currentVersion} / 最新 ${info.latestVersion ?? '-'}` +
`${info.hasUpdate ? '(有新版本)' : '(已是最新)'}`,
);
}
} catch (error) {
info = failure(describeFailure(error));
logger.warn(`更新检查失败:${info.error}(本机版本 ${currentVersion})`);
}
cache = { at: now, info };
return info;
}
/** 「知道了 / 忽略此版本」:记到配置里,同一个版本不再重复弹提示 */
export function ignoreUpdateVersion(version: string): void {
const normalized = normalizeVersion(version);
if (!normalized) return;
saveConfig({ ignoredUpdateVersion: normalized });
logger.info(`已忽略版本 ${normalized} 的更新提示`);
}
/** 该版本是否已被用户忽略 */
export function isUpdateIgnored(version: string): boolean {
return normalizeVersion(getConfig().ignoredUpdateVersion) === normalizeVersion(version);
}
/**
* 启动后的自动检查:延迟 `STARTUP_DELAY_MS` 查一次,有新版本(且没被忽略)就通知渲染进程弹提示。
*
* **冒烟模式直接跳过**:自动化验证不该每次都发真实网络请求(既抖动又依赖外网),
* 而且凭空多出来的提示条会撞坏既有 UI 断言。冒烟用例改为直接调 IPC 验证返回结构。
*/
export function scheduleStartupUpdateCheck(getWindow: () => BrowserWindow | null): void {
if (process.env.ELECTRON_SMOKE_TEST === '1') {
startupCheckSkipped = true;
logger.info('更新检查:冒烟模式下跳过启动自动检查');
return;
}
if (startupTimer) clearTimeout(startupTimer);
startupTimer = setTimeout(() => {
startupTimer = null;
void (async () => {
try {
const info = await checkForUpdates();
if (!info.ok || !info.hasUpdate || !info.latestVersion) return;
if (isUpdateIgnored(info.latestVersion)) {
logger.info(`更新检查:${info.latestVersion} 已被用户忽略,本次不提示`);
return;
}
const win = getWindow();
if (!win || win.isDestroyed()) return;
win.webContents.send(UPDATE_AVAILABLE_CHANNEL, info);
logger.info(`更新检查:已提示新版本 ${info.latestVersion}`);
} catch (error) {
// 自动检查失败不该打扰用户(手动检查才需要看到原因)
logger.warn(`启动自动检查更新失败:${error instanceof Error ? error.message : error}`);
}
})();
}, STARTUP_DELAY_MS);
// 不阻止进程退出:这个定时器只是"顺便查一下"
startupTimer.unref?.();
}
/** 冒烟断言用:启动自动检查是否被跳过(冒烟模式下应为 true —— 否则每次验证都会发真实网络请求) */
export function wasStartupCheckSkipped(): boolean {
return startupCheckSkipped;
}
+2 -11
View File
@@ -3,7 +3,7 @@ import type {
CoursewareTransfer,
} from '@classhelper/shared';
import { contextBridge, ipcRenderer } from 'electron';
import { IPC_CHANNELS, UPDATE_AVAILABLE_CHANNEL } from '../main/channels.js';
import { IPC_CHANNELS } from '../main/channels.js';
import type { ClientAgentStatus } from '../main/client-agent.js';
import type {
DesktopAppInfo,
@@ -12,7 +12,7 @@ import type {
IslandClassStatePayload,
IslandPushContext,
} from '../types/desktop.js';
import type { IslandNotification, UpdateInfo } from '@classhelper/shared';
import type { IslandNotification } from '@classhelper/shared';
/**
* 预加载脚本:在开启了 contextIsolation + sandbox 的前提下,
@@ -65,15 +65,6 @@ const bridge: DesktopBridge = {
getAppInfo: (): Promise<DesktopAppInfo> => ipcRenderer.invoke(IPC_CHANNELS.appInfo),
openExternal: (url: string): Promise<boolean> => ipcRenderer.invoke(IPC_CHANNELS.openExternal, url),
/* 更新检查(主进程直连 GitHub,见 main/update.ts) */
checkForUpdates: (force = false): Promise<UpdateInfo> =>
ipcRenderer.invoke(IPC_CHANNELS.updateCheck, force),
ignoreUpdateVersion: (version: string): Promise<void> =>
ipcRenderer.invoke(IPC_CHANNELS.updateIgnore, version),
onUpdateAvailable: (handler: (info: UpdateInfo) => void): void => {
ipcRenderer.on(UPDATE_AVAILABLE_CHANNEL, (_event, info: UpdateInfo) => handler(info));
},
islandPush: (payload: { notification: IslandNotification; context?: IslandPushContext }): void => {
ipcRenderer.send('island:push', payload);
},
+2 -53
View File
@@ -1,8 +1,6 @@
<script setup lang="ts">
import { h, onMounted, onUnmounted, ref } from 'vue';
import { onMounted, onUnmounted, ref } from 'vue';
import { useRouter } from 'vue-router';
import { ElButton, ElNotification } from 'element-plus';
import type { UpdateInfo } from '@classhelper/shared';
import {
replayMissedNotifications,
startIslandBridge,
@@ -28,56 +26,10 @@ const realtime = useRealtimeStore();
const booting = ref(true);
const bootText = ref('正在读取本地配置...');
/**
* 启动自动检查发现新版本时的提示(主进程查出后推过来,见 main/update.ts)。
*
* **为什么订阅放在 App.vue**:`onUpdateAvailable` 底层是 `ipcRenderer.on`,
* 桥接层没有对应的 off —— 挂在会随"登出 → 登录"反复挂载的 ClientLayout 里,
* 处理器会越堆越多(与灵动岛订阅同一个坑)。App.vue 整个应用生命周期只挂载一次。
*
* 提示是**一次性**且可永久消音:点「忽略此版本」写进 config.json,同一版本不再提示;
* 「关于」页里仍可随时手动检查。
*/
function showUpdateAvailable(info: UpdateInfo): void {
if (!info.latestVersion) return;
ElNotification({
title: `发现新版本 v${info.latestVersion}`,
type: 'info',
// 不自动消失:这是需要用户决定的事(去下载 / 忽略),滑过去就只能靠「关于」页再想起来
duration: 0,
message: h('div', { style: 'line-height: 1.7' }, [
h('p', { style: 'margin: 0 0 10px' }, `当前版本 ${info.currentVersion},可前往下载更新。`),
h('div', { style: 'display: flex; gap: 8px' }, [
h(
ElButton,
{
size: 'small',
type: 'primary',
onClick: () => {
void window.desktop?.openExternal(info.releaseUrl);
},
},
() => '前往下载',
),
h(
ElButton,
{
size: 'small',
onClick: () => {
void window.desktop?.ignoreUpdateVersion(info.latestVersion ?? '');
},
},
() => '忽略此版本',
),
]),
]),
});
}
/**
* 上线补弹「离线期间收到的消息」(需求 11)。
*
* **为什么订阅放在 App.vue**:与 `onUpdateAvailable` 同一条理由 —— App.vue 整个应用生命周期
* **为什么订阅放在 App.vue**:App.vue 整个应用生命周期
* 只挂载一次,而 `ClientLayout` 会随"登出 → 登录"反复挂载。而且恢复事件本身是"可达性由不可达
* 变为可达"的那一刻,一次会话里可能发生多次,处理器必须是**幂等**的(`replayMissedNotifications`
* 推完就清掉离线起点,重复触发时第二次读到空值、直接返回 0)。
@@ -118,9 +70,6 @@ onMounted(async () => {
// 离线期间收到的消息:可达性恢复的那一刻补弹到灵动岛(App.vue 常驻,所以每次恢复只跑一次)
appStore.onServerRecovered(handleServerRecovered);
// 启动自动检查发现新版本时由主进程推过来(订阅只挂一次,理由见 showUpdateAvailable)
window.desktop?.onUpdateAvailable?.(showUpdateAvailable);
if (auth.isAuthenticated) await router.replace('/schedule');
else await router.replace('/login');
@@ -61,7 +61,10 @@ http.interceptors.response.use(
const status = error.response.status;
const message = error.response.data?.message ?? `请求失败(${status})`;
if (status === 401) {
const loginAttempt =
error.config?.method?.toLowerCase() === 'post' &&
/\/auth\/(?:class-)?login\/?(?:\?|$)/.test(error.config?.url ?? '');
if (status === 401 && !loginAttempt) {
ElMessage.warning('登录状态已失效,请重新登录');
unauthorizedHandler();
} else {
+3 -9
View File
@@ -1168,18 +1168,12 @@ export async function aboutPageSelfTest(): Promise<SmokeCheckResult> {
const hasDiagnostics = text.includes('诊断信息');
const info = await window.desktop?.getAppInfo?.();
const hasConfigPath = Boolean(info?.configPath);
// 检查更新入口(新功能回归):关于页要有这一块,且按钮可点。
// 这里只断言"入口存在"——是否真有新版本取决于 GitHub,不该绑进冒烟(见 main/update.ts)
const updateBlock = document.querySelector('[data-test="update-check"]');
const updateButton = document.querySelector('[data-test="update-check-button"]');
const hasUpdateCheck = Boolean(document.querySelector('[data-test="update-check"]'));
await router.push('/schedule');
return {
ok: hasThanks && hasDiagnostics && hasConfigPath && Boolean(updateBlock) && Boolean(updateButton),
detail:
`鸣谢=${hasThanks} 诊断=${hasDiagnostics} configPath=${hasConfigPath ? '有' : '无'} ` +
`检查更新块=${updateBlock ? '有' : '无'} 按钮=${updateButton ? '有' : '无'}`,
ok: hasThanks && hasDiagnostics && hasConfigPath && !hasUpdateCheck,
detail: `鸣谢=${hasThanks} 诊断=${hasDiagnostics} configPath=${hasConfigPath ? '有' : '无'}`,
};
} catch (error) {
return {
@@ -54,7 +54,7 @@ const container = computed(() => ['group', 'stack', 'slide', 'rolling'].includes
display: flex;
align-items: center;
flex-shrink: 0;
border-radius: 5px;
border-radius: var(--ch-radius-control);
}
.component-chip {
display: flex;
@@ -62,9 +62,9 @@ const container = computed(() => ['group', 'stack', 'slide', 'rolling'].includes
gap: 5px;
min-height: 36px;
padding: 5px 9px;
border: 1px solid transparent;
border-radius: 5px;
background: transparent;
border: 1px solid var(--ch-border);
border-radius: var(--ch-radius-control);
background: var(--ch-surface);
color: inherit;
font: inherit;
white-space: nowrap;
@@ -6,7 +6,7 @@
min-width: 0;
color: var(--ch-text);
padding: 12px 24px 16px;
background: var(--editor-background, var(--ch-bg));
background: var(--ch-bg);
}
:global(.main:has(> .island-editor-page)) {
display: flex;
@@ -16,11 +16,6 @@
.island-editor-page > * {
flex-shrink: 0;
}
:global(html.dark) .island-editor-page {
--editor-background: #262626;
--editor-divider: #3a3a3a;
--editor-card: #2c2c2c;
}
.editor-actions {
display: flex;
align-items: center;
@@ -77,7 +72,8 @@
}
.scheme-controls :deep(.el-select__wrapper) {
min-height: 38px;
background: var(--ch-card-subtle);
background: var(--ch-surface);
border-radius: var(--ch-radius-control);
}
.icon-button {
width: 34px;
@@ -139,7 +135,7 @@
display: flex;
align-items: center;
min-height: 54px;
border-radius: 6px;
border-radius: var(--ch-radius-control);
gap: 12px;
padding: 4px;
border: 1px solid transparent;
@@ -180,7 +176,7 @@
background: transparent;
color: var(--ch-text-tertiary);
padding: 10px 24px;
border-radius: 5px;
border-radius: var(--ch-radius-control);
font: inherit;
font-size: 12px;
cursor: pointer;
@@ -251,7 +247,7 @@
font-size: 12px;
}
.component-library {
border-top: 6px solid var(--editor-divider, var(--ch-divider));
border-top: 1px solid var(--ch-border);
margin: 0 -24px;
padding: 14px 24px 24px;
flex: 1 0 auto;
@@ -288,9 +284,9 @@
text-align: left;
min-height: 76px;
padding: 10px 8px;
border: 1px solid transparent;
border-radius: 6px;
background: transparent;
border: 1px solid var(--ch-border);
border-radius: var(--ch-radius-control);
background: var(--ch-surface);
color: inherit;
font: inherit;
cursor: grab;
@@ -332,51 +328,6 @@
font-size: calc(14px * var(--ch-font-scale));
line-height: 1.5;
}
.message-library-title {
color: var(--ch-text-tertiary);
font-size: 12px;
font-weight: 400;
margin: 20px 8px 4px;
}
.message-options .library-item {
min-height: 64px;
}
.message-options .library-item strong {
font-size: 15px;
}
.message-options .library-item > svg {
width: 26px;
height: 26px;
flex-basis: 26px;
}
.editor-tip {
display: flex;
align-items: center;
gap: 14px;
padding: 12px 16px;
min-height: 60px;
border: 1px solid var(--ch-border-strong);
border-radius: 5px;
background: var(--editor-card, var(--ch-card-subtle));
font-size: 14px;
}
.editor-tip > span {
flex: 1;
line-height: 1.6;
}
.tip-icon {
color: var(--ch-accent);
font-size: 22px;
}
.dismiss-tip {
border: 0;
color: var(--ch-text);
background: transparent;
font-size: 26px;
cursor: pointer;
margin-left: auto;
padding: 0 8px;
}
.drag-ghost {
position: fixed;
z-index: 10000;
@@ -392,6 +343,22 @@
.inspector-tabs {
margin-bottom: 20px;
}
:global(.island-inspector) {
color: var(--ch-text);
background: var(--ch-surface);
}
:global(.island-inspector .el-drawer__header) {
color: var(--ch-text);
}
:global(.island-inspector .el-input-number),
:global(.island-inspector .el-select) {
width: 100%;
}
:global(.island-inspector .el-input__wrapper),
:global(.island-inspector .el-select__wrapper) {
background: var(--ch-surface);
border-radius: var(--ch-radius-control);
}
.row-actions {
display: flex;
gap: 6px;
@@ -426,9 +393,6 @@
.scheme-tools {
flex: 1 1 100%;
}
.editor-tip {
flex-wrap: wrap;
}
.preview-toolbar .hint {
display: none;
}
@@ -1,14 +1,12 @@
<script setup lang="ts">
import UpdateProgress from '../../components/UpdateProgress.vue';
import { onMounted, ref } from 'vue';
import { ElMessage } from 'element-plus';
import type { UpdateInfo } from '@classhelper/shared';
import type { DesktopAppInfo } from '../../../types/desktop.js';
import { useAppStore } from '../../stores/app.js';
/**
* 关于(ClassIsland 同款折叠卡片式):
* 应用信息(版本/运行时/常用链接/检查更新)→ 诊断信息(排查问题用)→ 鸣谢。
* 应用信息(版本/运行时/常用链接)→ 诊断信息(排查问题用)→ 鸣谢。
* 所有外链走主进程 openExternal(只放行 http/https,见 main/ipc.ts 的白名单)。
*/
const appStore = useAppStore();
@@ -17,10 +15,6 @@ const appInfo = ref<DesktopAppInfo | null>(null);
/** 折叠面板默认展开第一项(应用信息),诊断信息默认收起 */
const expandedNames = ref(['app']);
/** 检查更新:结果由主进程直连 GitHub 得到(见 main/update.ts) */
const checking = ref(false);
const updateInfo = ref<UpdateInfo | null>(null);
const PROJECT_URL = 'https://github.com/LoveChengke/ClassHelper';
const ISSUES_URL = 'https://github.com/LoveChengke/ClassHelper/issues';
@@ -38,40 +32,16 @@ async function openExternal(url: string): Promise<void> {
window.open(url, '_blank');
}
/**
* 检查更新。
*
* @param force true = 用户主动点击(绕过主进程缓存);false = 进页面时带出启动自动检查的结果
*/
async function checkUpdate(force: boolean): Promise<void> {
if (!window.desktop?.checkForUpdates) return;
checking.value = true;
try {
updateInfo.value = await window.desktop.checkForUpdates(force);
} finally {
checking.value = false;
}
}
/** 忽略这个版本:写进配置,启动自动检查不再提示它 */
async function ignoreVersion(): Promise<void> {
const version = updateInfo.value?.latestVersion;
if (!version) return;
await window.desktop?.ignoreUpdateVersion(version);
ElMessage.success(`已忽略 v${version} 的更新提示`);
}
onMounted(async () => {
if (!window.desktop) return;
appInfo.value = await window.desktop.getAppInfo().catch(() => null);
// 带出启动自动检查的结果(命中主进程缓存,不会再发一次请求)
void checkUpdate(false);
});
</script>
<template>
<div class="page">
<UpdateProgress />
<p class="text-muted">客户端更新由管理端统一下发。</p>
<div class="page-header">
<div>
<h2 class="page-title">关于</h2>
@@ -107,51 +77,6 @@ onMounted(async () => {
</el-descriptions-item>
<el-descriptions-item label="平台">{{ appInfo?.platform ?? '-' }}</el-descriptions-item>
</el-descriptions>
<!-- 检查更新:直连 GitHub 看最新的 Release 是不是比本机新 -->
<div class="about-update" data-test="update-check">
<div class="about-update-head">
<span class="about-update-label">检查更新</span>
<el-button
size="small"
:loading="checking"
data-test="update-check-button"
@click="checkUpdate(true)"
>
检查更新
</el-button>
</div>
<div class="about-update-body">
<template v-if="checking">正在检查…</template>
<template v-else-if="!updateInfo">尚未检查</template>
<template v-else-if="!updateInfo.ok">
<!-- 教室机器没有外网是常态,这里只是"查不到",不是错误 -->
<span class="about-update-muted">{{ updateInfo.error ?? '暂时无法检查更新' }}</span>
</template>
<template v-else-if="updateInfo.hasUpdate">
<el-tag size="small" type="success" effect="light">
发现新版本 v{{ updateInfo.latestVersion }}
</el-tag>
<span class="about-update-muted">当前 v{{ updateInfo.currentVersion }}</span>
<el-button
link
type="primary"
size="small"
data-test="update-download"
@click="openExternal(updateInfo.releaseUrl)"
>
前往下载
</el-button>
<el-button link size="small" @click="ignoreVersion">忽略此版本</el-button>
</template>
<template v-else>
<el-tag size="small" type="info" effect="plain">已是最新版本</el-tag>
<span class="about-update-muted">
v{{ updateInfo.currentVersion }} · {{ updateInfo.latestVersion }}
</span>
</template>
</div>
</div>
</div>
</el-collapse-item>
@@ -248,55 +173,4 @@ onMounted(async () => {
color: var(--ch-text-secondary);
margin-right: 4px;
}
/* 检查更新:颜色一律走 --ch-* 变量(深色主题下不能写死浅色底/深色字) */
.about-update {
margin-top: 12px;
padding: 10px 12px;
border: 1px solid var(--ch-border);
border-radius: var(--ch-radius-card);
background: var(--ch-layer-alt);
}
.about-update-head {
display: flex;
align-items: center;
justify-content: space-between;
gap: 8px;
}
.about-update-label {
font-size: 12.5px;
font-weight: 600;
color: var(--ch-text-secondary);
}
.about-update-body {
display: flex;
align-items: center;
flex-wrap: wrap;
gap: 8px;
margin-top: 8px;
font-size: 12.5px;
color: var(--ch-text);
}
.about-update-muted {
color: var(--ch-text-tertiary);
}
.about-thanks {
margin: 0;
padding-left: 18px;
line-height: 2;
font-size: 12.5px;
color: var(--ch-text-secondary);
}
.about-quote {
margin: 18px 0 4px;
text-align: center;
font-size: 12px;
color: var(--ch-text-tertiary);
}
</style>
@@ -2,7 +2,7 @@
import { confirmAction } from '../../composables/confirm.js';
import { computed, onMounted, ref } from 'vue';
import { ElMessage } from 'element-plus';
import { formatDate, relativeTime, type UpdateInfo } from '@classhelper/shared';
import { formatDate, relativeTime } from '@classhelper/shared';
import type { ClientAgentStatus, DesktopAppInfo } from '../../../types/desktop.js';
import { useAppStore } from '../../stores/app.js';
import { useUiStore } from '../../stores/ui.js';
@@ -42,7 +42,6 @@ async function loadAll(): Promise<void> {
try {
await loadAppInfo();
await refreshAgent();
await loadIgnoredVersion();
await appStore.refreshCacheStats();
} finally {
loading.value = false;
@@ -110,51 +109,6 @@ async function openLogDir(): Promise<void> {
if (!ok) ElMessage.warning('打开日志目录失败,请按上面的路径手动前往');
}
/* ------------------------------------------------------------ 更新 */
/**
* 更新检查。
*
* 「立即检查」走 `checkForUpdates(true)`:**强制绕过主进程那 30 分钟缓存**。
* 这是本页与「关于」页的区别 —— 那边用户点检查也可能是缓存结果(省流量),
* 这边维护者要的是"现在到底拿得到什么",所以按钮默认就是强制的。
*/
const checking = ref(false);
const updateInfo = ref<UpdateInfo | null>(null);
const ignoredUpdateVersion = ref('');
async function checkUpdate(force: boolean): Promise<void> {
if (!window.desktop?.checkForUpdates) return;
checking.value = true;
try {
updateInfo.value = await window.desktop.checkForUpdates(force);
} finally {
checking.value = false;
}
}
async function loadIgnoredVersion(): Promise<void> {
if (!window.desktop?.getConfig) return;
const stored = await window.desktop.getConfig().catch(() => null);
ignoredUpdateVersion.value = stored?.ignoredUpdateVersion ?? '';
}
async function ignoreVersion(): Promise<void> {
const version = updateInfo.value?.latestVersion;
if (!version || !window.desktop?.ignoreUpdateVersion) return;
await window.desktop.ignoreUpdateVersion(version);
ignoredUpdateVersion.value = version;
ElMessage.success(`已忽略 v${version}:启动时的自动检查不再提示它`);
}
/** 忽略是可逆的(排查线上"用户说不再提示"时经常要把它清掉),顺手给一个恢复入口 */
async function clearIgnoredVersion(): Promise<void> {
if (!window.desktop?.saveConfig) return;
const saved = await window.desktop.saveConfig({ ignoredUpdateVersion: '' });
ignoredUpdateVersion.value = saved.ignoredUpdateVersion;
ElMessage.success('已恢复该版本的更新提示');
}
/* ------------------------------------------------------------ 调试工具 */
const openingDevTools = ref(false);
@@ -211,8 +165,6 @@ async function clearCache(): Promise<void> {
onMounted(async () => {
await loadAll();
// 带出启动自动检查的结果(这次命中主进程缓存,不会真的再发一次请求)
void checkUpdate(false);
});
</script>
@@ -326,56 +278,6 @@ onMounted(async () => {
</div>
</el-card>
<!-- 更新 -->
<el-card shadow="never" class="mt-12">
<template #header><span>更新</span></template>
<div class="toolbar">
<el-button :loading="checking" data-test="dev-check-update" @click="checkUpdate(true)">
强制检查更新
</el-button>
<span class="text-muted">绕过主进程 30 分钟缓存,直接问 GitHub</span>
</div>
<el-descriptions :column="1" border size="small" class="mt-12">
<el-descriptions-item label="本次结果">
<template v-if="checking">正在检查…</template>
<template v-else-if="!updateInfo">尚未检查</template>
<template v-else-if="!updateInfo.ok">
<span class="text-muted">{{ updateInfo.error ?? '暂时无法检查更新' }}</span>
</template>
<template v-else-if="updateInfo.hasUpdate">
<el-tag size="small" type="success" effect="light">
有新版本 v{{ updateInfo.latestVersion }}
</el-tag>
<span class="text-muted">当前 v{{ updateInfo.currentVersion }}</span>
</template>
<template v-else>
<el-tag size="small" type="info" effect="plain">已是最新版本</el-tag>
<span class="text-muted">v{{ updateInfo.currentVersion }}</span>
</template>
</el-descriptions-item>
<el-descriptions-item label="检查时间">
{{ updateInfo?.checkedAt ? formatDate(updateInfo.checkedAt, true) : '—' }}
</el-descriptions-item>
<el-descriptions-item label="已忽略的版本">
<template v-if="ignoredUpdateVersion">
<span class="mono">v{{ ignoredUpdateVersion }}</span>
<el-button link type="primary" size="small" @click="clearIgnoredVersion">恢复提示</el-button>
</template>
<span v-else class="text-muted">无</span>
</el-descriptions-item>
</el-descriptions>
<div class="toolbar mt-12">
<el-button
:disabled="!updateInfo?.latestVersion"
data-test="dev-ignore-version"
@click="ignoreVersion"
>
不再提示该版本
</el-button>
<span class="text-muted">写入配置后,启动时的自动检查会跳过它</span>
</div>
</el-card>
<!-- 调试工具 -->
<el-card shadow="never" class="mt-12">
<template #header><span>调试工具</span></template>
@@ -37,7 +37,6 @@ const selectedId = ref(''),
rowId = ref(''),
inspectorOpen = ref(false),
editMode = ref(false),
showTip = ref(true),
zoom = ref(1),
importInput = ref<HTMLInputElement>();
const scheme = computed(() =>
@@ -69,11 +68,6 @@ const library: { kind: IslandComponentKind; description: string }[] = [
{ kind: 'group', description: '将多个组件组合到一个组件中显示。' },
{ kind: 'stack', description: '将多个容器堆叠显示。' },
];
const messageLibrary: { kind: IslandComponentKind; description: string }[] = [
{ kind: 'notification', description: '显示班级收到的通知。' },
{ kind: 'homework', description: '显示班级作业提醒。' },
{ kind: 'call', description: '显示教师的叫人提醒。' },
];
const containers: readonly string[] = ['group', 'stack', 'slide', 'rolling'];
function id() {
return crypto.randomUUID();
@@ -773,34 +767,7 @@ function dropPreview(event: PointerEvent) {
</span>
</button>
</div>
<h4 class="message-library-title">班级消息</h4>
<div class="component-options message-options">
<button
v-for="item in messageLibrary"
:key="item.kind"
class="library-item"
:data-library-kind="item.kind"
:aria-label="`添加${ISLAND_COMPONENT_LABELS[item.kind]}`"
@pointerdown="beginDrag($event, { kind: item.kind, label: ISLAND_COMPONENT_LABELS[item.kind] })"
@click="add(item.kind)"
>
<ComponentIcon :kind="item.kind" />
<span>
<strong>{{ ISLAND_COMPONENT_LABELS[item.kind] }}</strong>
<span class="component-description">{{ item.description }}</span>
</span>
</button>
</div>
</section>
<div v-if="showTip" class="editor-tip" role="note">
<el-icon class="tip-icon"><InfoFilled /></el-icon>
<span>
<strong>编辑提示:</strong>
现在可以使用「编辑模式」更加直观地编辑主界面上的组件!
</span>
<el-button @click="editMode = !editMode">{{ editMode ? '退出编辑模式' : '进入编辑模式' }}</el-button>
<button class="dismiss-tip" aria-label="关闭编辑提示" @click="showTip = false">×</button>
</div>
</template>
<el-skeleton v-else :rows="8" animated />
<input ref="importInput" type="file" accept="application/json,.json" hidden @change="importScheme" />
@@ -5,6 +5,7 @@ import { ElMessage } from 'element-plus';
import { useRouter } from 'vue-router';
import {
DEFAULT_ISLAND_APPEARANCE,
defaultIslandLayouts,
ISLAND_APPEARANCE_RANGES as RANGES,
ISLAND_POSITION_LABELS,
ISLAND_POSITIONS,
@@ -30,6 +31,13 @@ function editLayout() {
void router.push('/settings/island/editor');
}
const layoutMode = ref<'fixed' | 'custom'>('fixed');
const layoutSettings = ref(defaultIslandLayouts());
const activeScheme = computed(() =>
layoutSettings.value.schemes.find((s) => s.id === layoutSettings.value.activeSchemeId)!,
);
const currentRadius = computed(() =>
layoutMode.value === 'custom' ? activeScheme.value.radius : island.value.radius,
);
const residentEnabled = ref(false);
const pointerFadeEnabled = ref(true);
const pointerFadeReversed = ref(false);
@@ -65,6 +73,7 @@ async function changePointerFade(
}
async function loadLayout() {
const settings = (await window.desktop?.getConfig())?.islandLayout;
if (settings) layoutSettings.value = settings;
layoutMode.value = settings?.layout ?? 'fixed';
residentEnabled.value = settings?.residentEnabled ?? false;
pointerFadeEnabled.value = settings?.pointerFadeEnabled ?? true;
@@ -103,6 +112,12 @@ async function loadIslandAppearance(): Promise<void> {
/** 改动即生效:属性变化时先应用(实时预览),点"保存"再落盘 */
function applyIslandAppearance(patch: Partial<IslandAppearance> = {}): void {
island.value = { ...island.value, ...patch };
if (layoutMode.value === 'custom' && patch.radius !== undefined) {
activeScheme.value.radius = patch.radius;
void window.desktop
?.saveConfig({ islandLayout: JSON.parse(JSON.stringify(layoutSettings.value)) })
.catch(() => ElMessage.error('圆角保存失败,请重试'));
}
window.desktop?.islandSetAppearance({ ...island.value });
}
@@ -230,9 +245,9 @@ onMounted(async () => {
@input="(value: number) => applyIslandAppearance({ width: value })"
/>
</el-form-item>
<el-form-item :label="`圆角 ${island.radius}px`">
<el-form-item :label="`圆角 ${currentRadius}px`">
<el-slider
:model-value="island.radius"
:model-value="currentRadius"
:min="RANGES.radius.min"
:max="RANGES.radius.max"
:step="1"
@@ -55,7 +55,7 @@ onMounted(loadGradeQuery);
<el-card shadow="never" class="lesson-channel-settings">
<template #header>上下课提醒</template>
<p class="text-muted">
沿用 ClassIsland 的遮罩、课前倒计时、上下课提示及下节课预告;课中显示课程进度,临近下课显示倒数。
课前倒计时、上下课提示及下节课预告保留遮罩;课中显示课程进度,临近下课在课程名右侧显示蓝色圆形秒数倒计时。
</p>
<div
v-for="channel in [
+2 -22
View File
@@ -9,7 +9,7 @@ import type {
* 主进程与渲染进程之间的桥接契约(preload 通过 contextBridge 暴露)。
* 渲染进程只依赖这些最小 API,不接触 Node.js。
*/
import type { IslandAppearance, IslandNotification, IslandState, UpdateInfo } from '@classhelper/shared';
import type { IslandAppearance, IslandNotification, IslandState } from '@classhelper/shared';
import type { ClientAgentStatus } from '../main/client-agent.js';
import type { IslandBridge } from '../preload/island.js';
@@ -55,12 +55,7 @@ export interface DesktopStoredConfig {
theme: 'light' | 'dark';
/** 主侧边栏是否折叠成图标栏(可由顶栏汉堡按钮切换) */
sidebarCollapsed: boolean;
/**
* 用户点过「忽略此版本」的版本号(空串 = 没忽略过)。
*
* 启动时的自动检查会跳过这个版本,避免每次开客户端都弹一次同样的提示;
* 在「关于」页手动检查时仍会正常显示结果。
*/
/** 旧版主动更新检查的兼容字段,不再影响云端下发更新。 */
ignoredUpdateVersion: string;
/**
* 本机设备标识(UUID):这台机器在服务端的身份。
@@ -159,21 +154,6 @@ export interface DesktopBridge {
getAppInfo(): Promise<DesktopAppInfo>;
openExternal(url: string): Promise<boolean>;
/* 更新检查 */
/**
* 检查 GitHub 上有没有新版本(主进程直连,不经后端)。
*
* @param force true = 绕过主进程缓存(对应「关于」页里用户主动点的那次检查)
*
* 返回的 `ok:false` 是**正常结果**(教室机器没有外网 / GitHub 限流 / 超时),不是异常,
* 界面按"暂时查不到更新"呈现即可。
*/
checkForUpdates(force?: boolean): Promise<UpdateInfo>;
/** 忽略某个版本的更新提示(写入 config.json,启动自动检查不再提示它) */
ignoreUpdateVersion(version: string): Promise<void>;
/** 订阅"启动自动检查发现新版本"(仅新版本且未被忽略时触发一次) */
onUpdateAvailable(handler: (info: UpdateInfo) => void): void;
/* 灵动岛 */
getIslandWeather(coordinates: { latitude: number; longitude: number }): Promise<IslandWeather>;
/** 把一条通知投递到灵动岛(payload 必须是纯数据,说明见 saveConfig) */
+1 -1
View File
@@ -1,6 +1,6 @@
{
"name": "@classhelper/server",
"version": "1.4.4",
"version": "1.4.5",
"private": true,
"description": "ClassHelper后端服务:REST API + Socket.IO 实时推送 + Prisma 数据访问",
"//": "yaml:课表 YAML 导入的解析器(yaml@2,自带类型、无子依赖);仓库只有传递依赖 js-yaml,不要直接引用",
+10 -1
View File
@@ -437,11 +437,20 @@ try {
coursewareCategory('a.7z') === 'archive',
);
await restoreSnapshot(prisma, 'sqlite', snapshot);
const restoredFolders = await prisma.coursewareFolder.findMany();
check(
'恢复数据库后保留课件共享和回执数据',
(await prisma.courseware.count()) === 3 &&
(await prisma.coursewareReceipt.count()) === 1 &&
(await prisma.coursewareFolder.count()) === 1,
restoredFolders.length === snapshot.data.CoursewareFolder.length &&
snapshot.data.CoursewareFolder.every((expected) =>
restoredFolders.some(
(actual) =>
actual.id === expected.id &&
actual.path === expected.path &&
actual.teacherId === expected.teacherId,
),
),
);
console.log(`=== 课件隔离验收:${count}/${count} 项通过 ===`);
} finally {
+44 -6
View File
@@ -3223,7 +3223,8 @@ async function main() {
// 教师名单表格导入:教师预览 403;管理员预览 + 提交(教师与班级无关,classId 可省略)
const teacherCsv =
'\ufeff工号,姓名,初始密码,角色\n' +
`imp_t_${Date.now().toString().slice(-8)},冒烟导入教师,import123456,教师\n`;
`imp_t_${Date.now().toString().slice(-8)},冒烟导入教师,import123456,教师\n` +
`imp_t_${Date.now().toString().slice(-8)}_b,冒烟导入教师乙,import123456,教师\n`;
const teacherCsvBase64 = Buffer.from(teacherCsv, 'utf8').toString('base64');
const importedTeacherUsername = teacherCsv.split('\n')[1]?.split(',')[0] ?? '';
@@ -3250,7 +3251,10 @@ async function main() {
});
const importedTeacherLogin = await api('/auth/login', {
method: 'POST',
body: { username: importedTeacherUsername, password: 'import123456' },
body: {
username: importedTeacherUsername,
password: adminTeacherCommit.payload?.data?.credentials?.[0]?.password ?? '',
},
});
record(
'教师名单表格导入(教师 403 / 管理员预览+导入成功,且导入账号可登录)',
@@ -3258,13 +3262,47 @@ async function main() {
adminTeacherPreview.status === 200 &&
Boolean(adminTeacherPreview.payload?.data?.suggestedMapping?.username) &&
adminTeacherCommit.status === 200 &&
adminTeacherCommit.payload?.data?.inserted === 1 &&
adminTeacherCommit.payload?.data?.inserted === 2 &&
adminTeacherCommit.payload?.data?.credentials?.[0]?.password !== 'import123456' &&
importedTeacherLogin.status === 200,
`教师预览=${teacherPreviewDenied.status} 管理员预览=${adminTeacherPreview.status} ` +
`建议映射=${JSON.stringify(adminTeacherPreview.payload?.data?.suggestedMapping ?? {})} ` +
`导入新增=${adminTeacherCommit.payload?.data?.inserted ?? '-'} 登录=${importedTeacherLogin.status}`,
);
const importedCredentials = adminTeacherCommit.payload?.data?.credentials ?? [];
const repeatedImport = await api('/imports/table/commit', {
method: 'POST',
token: adminToken,
body: {
kind: 'teachers',
fileName: 'teachers.csv',
contentBase64: teacherCsvBase64,
mapping: { username: '工号', name: '姓名', role: '角色' },
mode: 'upsert',
},
});
const repeatLogin = await api('/auth/login', {
method: 'POST',
body: { username: importedTeacherUsername, password: importedCredentials[0]?.password ?? '' },
});
const importAudits = await api('/permissions/audit?pageSize=100', { token: adminToken });
const teacherImportAudits = (importAudits.payload?.data?.items ?? []).filter(
(item) => item.action === 'import-commitTeachers',
);
record(
'教师导入逐人生成随机密码,重复导入不重置且审计不含凭据',
importedCredentials.length === 2 &&
new Set(importedCredentials.map((c) => c.password)).size === 2 &&
importedCredentials.every((c) => c.password.length >= 16 && c.password !== 'import123456') &&
repeatedImport.payload?.data?.updated === 2 &&
repeatedImport.payload?.data?.credentials?.length === 0 &&
repeatLogin.status === 200 &&
teacherImportAudits.length > 0 &&
teacherImportAudits.every((item) => !/password|credentials/.test(item.afterJson)),
`凭据=${importedCredentials.length} 重复更新=${repeatedImport.payload?.data?.updated ?? '-'} 登录=${repeatLogin.status}`,
);
// 删除护栏:还是班主任的账号不允许删除;没有班级职责的可以删
const deleteHeadTeacher = teacher1
? await api(`/teachers/${teacher1.id}`, { method: 'DELETE', token: adminToken })
@@ -3661,10 +3699,10 @@ async function main() {
await api(`/classes/${probeClassId}`, { method: 'DELETE', token: adminToken });
}
}
const importedTeacherRow = (await api('/teachers', { token: adminToken })).payload?.data?.find(
(item) => item.username === importedTeacherUsername,
const importedTeacherRows = (await api('/teachers', { token: adminToken })).payload?.data?.filter((item) =>
importedCredentials.some((credential) => credential.username === item.username),
);
if (importedTeacherRow) {
for (const importedTeacherRow of importedTeacherRows ?? []) {
await api(`/teachers/${importedTeacherRow.id}`, { method: 'DELETE', token: adminToken });
}
const isProbeAccount = (username) =>
+38 -13
View File
@@ -1,6 +1,6 @@
import type { RequestHandler } from 'express';
import helmet from 'helmet';
import { rateLimit } from 'express-rate-limit';
import { ipKeyGenerator, rateLimit } from 'express-rate-limit';
import { env } from '../config/env.js';
import { logger } from '../lib/logger.js';
@@ -78,25 +78,50 @@ export function apiRateLimiter(): RequestHandler {
return limiter;
}
/** 登录接口专用限流:防暴力破解 */
/** 两种登录入口共用来源 IP:连续五次密码错误,从第五次失败起封禁五分钟。 */
export function loginRateLimiter(): RequestHandler {
return rateLimit({
windowMs: 10 * 60 * 1000,
limit: env.isProduction ? 20 : 200,
standardHeaders: 'draft-7',
legacyHeaders: false,
skipSuccessfulRequests: true,
skip: () => !env.rateLimitEnabled,
handler: (req, res) => {
logger.warn(`登录尝试过于频繁:${req.ip ?? '-'}`);
const duration = 5 * 60 * 1000;
const attempts = new Map<string, { failures: number; expiresAt: number; blockedUntil: number }>();
let sweepAt = 0;
return (req, res, next) => {
if (!env.rateLimitEnabled) return next();
const now = Date.now();
if (now >= sweepAt) {
for (const [key, attempt] of attempts) {
if (attempt.expiresAt <= now) attempts.delete(key);
}
sweepAt = now + 60_000;
}
const key = ipKeyGenerator(req.ip ?? req.socket.remoteAddress ?? 'unknown');
let attempt = attempts.get(key);
if (attempt && attempt.expiresAt <= now) {
attempts.delete(key);
attempt = undefined;
}
if (attempt && attempt.blockedUntil > now) {
res.setHeader('Retry-After', Math.ceil((attempt.blockedUntil - now) / 1000));
res.status(429).json({
success: false,
data: null,
message: '登录尝试过于频繁,请 10 分钟后再试',
message: '连续五次密码错误,已封禁登录 5 分钟,请稍后再试',
code: 'TOO_MANY_REQUESTS',
});
},
return;
}
res.once('finish', () => {
if (res.statusCode >= 200 && res.statusCode < 300) {
attempts.delete(key);
} else if (res.statusCode === 401) {
const finishedAt = Date.now();
const previous = attempts.get(key);
const failures = (previous && previous.expiresAt > finishedAt ? previous.failures : 0) + 1;
const blockedUntil = failures >= 5 ? previous?.blockedUntil || finishedAt + duration : 0;
attempts.set(key, { failures, blockedUntil, expiresAt: blockedUntil || finishedAt + duration });
if (failures === 5) logger.warn(`连续五次登录失败,封禁五分钟:${req.ip ?? '-'}`);
}
});
next();
};
}
/**
@@ -1,3 +1,4 @@
import { randomBytes } from 'node:crypto';
import { refreshClassSubscriptions } from '../../realtime/bus.js';
import { assertAdmin, assertManage, assertContentWrite } from '../../lib/authz/index.js';
import { changeStudentLifecycle, notifyStudentClasses } from '../../lib/student-lifecycle.js';
@@ -7,7 +8,6 @@ import * as XLSX from 'xlsx';
import { formatClassName, normalizeStudentNo, type TableImportKind } from '@classhelper/shared';
import { activeStudentWhere, isActiveStudent } from '../../lib/students.js';
import { prisma } from '../../lib/db.js';
import { env } from '../../config/env.js';
import { ApiError } from '../../lib/http.js';
import type { TokenPayload } from '../../lib/jwt.js';
import { logger } from '../../lib/logger.js';
@@ -98,7 +98,6 @@ export const IMPORT_FIELDS: Record<ImportKind, ImportField[]> = {
},
{ key: 'name', label: '姓名', required: true, synonyms: ['姓名', 'name', '教师', '教师姓名'] },
{ key: 'phone', label: '手机号', required: false, synonyms: ['手机号', '电话', 'phone', '联系方式'] },
{ key: 'password', label: '初始密码', required: false, synonyms: ['密码', 'password', '初始密码'] },
{
key: 'role',
label: '角色',
@@ -226,7 +225,7 @@ function parseTable(buffer: Buffer, fileName: string): ParsedTable {
const TEMPLATE_SAMPLES: Record<ImportKind, (string | number)[]> = {
grades: ['202601', '王小明', '期中考试', 92, 100, '数学', 'A'],
students: ['202601', '王小明', '2026级1班', '男', '13800000000'],
teachers: ['T1001', '王老师', '13800000000', 'teacher123', '教师'],
teachers: ['T1001', '王老师', '13800000000', '教师'],
classTeachers: ['2026级1班', '数学', 'T1001', '王老师', '科任'],
};
@@ -311,6 +310,7 @@ export interface ImportResult {
failed: number;
errors: ImportRowError[];
warnings: string[];
credentials?: { username: string; name: string; password: string }[];
}
function cellValue(row: string[], columns: string[], mapping: Record<string, string>, key: string): string {
@@ -677,6 +677,7 @@ export async function commitTeachers(user: TokenPayload, input: TableCommitInput
const errors: ImportRowError[] = [];
const warnings: string[] = [];
const credentials: NonNullable<ImportResult['credentials']> = [];
let inserted = 0;
let updated = 0;
let skipped = 0;
@@ -686,7 +687,6 @@ export async function commitTeachers(user: TokenPayload, input: TableCommitInput
const username = cellValue(row, parsed.columns, input.mapping, 'username');
const name = cellValue(row, parsed.columns, input.mapping, 'name');
const phone = cellValue(row, parsed.columns, input.mapping, 'phone');
const password = cellValue(row, parsed.columns, input.mapping, 'password');
const roleCell = cellValue(row, parsed.columns, input.mapping, 'role');
if (!username || !name) {
@@ -715,7 +715,7 @@ export async function commitTeachers(user: TokenPayload, input: TableCommitInput
});
updated += 1;
} else {
const initialPassword = password || env.defaultTeacherPassword;
const initialPassword = `Ch!${randomBytes(12).toString('base64url')}`;
await tx.user.create({
data: {
username,
@@ -726,6 +726,7 @@ export async function commitTeachers(user: TokenPayload, input: TableCommitInput
},
});
inserted += 1;
credentials.push({ username, name, password: initialPassword });
}
}
@@ -753,7 +754,7 @@ export async function commitTeachers(user: TokenPayload, input: TableCommitInput
afterJson: JSON.stringify(result),
},
});
return result;
return { ...result, credentials };
},
{ timeout: 30000 },
);
@@ -788,6 +789,7 @@ export async function commitClassTeachers(
const errors: ImportRowError[] = [];
const warnings: string[] = [];
const credentials: NonNullable<ImportResult['credentials']> = [];
let inserted = 0;
let updated = 0;
let skipped = 0;
@@ -877,19 +879,25 @@ export async function commitClassTeachers(
}
await assertPermission(user, 'teacher:manage');
await assertPermission(user, 'import:teachers');
const initialPassword = `Ch!${randomBytes(12).toString('base64url')}`;
const created = await tx.user.create({
data: {
username: teacherNo,
name: teacherName || teacherNo,
role: 'TEACHER',
passwordHash: await hashPassword(env.defaultTeacherPassword),
passwordHash: await hashPassword(initialPassword),
},
select: { id: true },
});
teacherId = created.id;
inserted += 1;
credentials.push({
username: teacherNo,
name: teacherName || teacherNo,
password: initialPassword,
});
warnings.push(
`第 ${rowNumber} 行:工号 ${teacherNo} 没有对应账号,已新建教师「${teacherName || teacherNo}」(初始密码见部署配置)`,
`第 ${rowNumber} 行:工号 ${teacherNo} 没有对应账号,已新建教师「${teacherName || teacherNo}」,请保存本次生成的随机密码`,
);
}
createdTeachers.set(teacherNo.toLowerCase(), teacherId);
@@ -947,7 +955,7 @@ export async function commitClassTeachers(
afterJson: JSON.stringify(result),
},
});
return result;
return { ...result, credentials };
},
{ timeout: 30000 },
)
+1 -1
View File
@@ -1,6 +1,6 @@
{
"name": "@classhelper/shared",
"version": "1.4.4",
"version": "1.4.5",
"private": true,
"description": "ClassHelper - 三端共享的类型、常量与工具函数",
"type": "module",
+2
View File
@@ -1313,6 +1313,8 @@ export interface TableImportResult {
failed: number;
errors: TableImportRowError[];
warnings: string[];
/** 仅在新建教师的导入响应中返回,供管理员一次性分发;不写审计记录。 */
credentials?: { username: string; name: string; password: string }[];
}
/** ClassIsland 时间配置条目 */
+1 -1
View File
@@ -1,6 +1,6 @@
{
"name": "@classhelper/ui",
"version": "1.4.4",
"version": "1.4.5",
"private": true,
"type": "module",
"exports": {
+1 -1
View File
@@ -1,6 +1,6 @@
{
"name": "@classhelper/web-admin",
"version": "1.4.4",
"version": "1.4.5",
"private": true,
"description": "ClassHelper Web 管理端(Vue 3 + Vite + Element Plus)",
"type": "module",
+4 -1
View File
@@ -39,7 +39,10 @@ instance.interceptors.response.use(
const status = error.response?.status;
const message = error.response?.data?.message ?? error.message ?? '网络请求失败';
if (status === 401) {
const loginAttempt =
error.config?.method?.toLowerCase() === 'post' &&
/\/auth\/(?:class-)?login\/?(?:\?|$)/.test(error.config?.url ?? '');
if (status === 401 && !loginAttempt) {
clearCalendarCache();
localStorage.removeItem(STORAGE_KEYS.token);
localStorage.removeItem(STORAGE_KEYS.user);
@@ -55,7 +55,6 @@ const FIELDS: Record<Kind, FieldDef[]> = {
{ key: 'username', label: '工号', required: true },
{ key: 'name', label: '姓名', required: true },
{ key: 'phone', label: '手机号', required: false },
{ key: 'password', label: '初始密码', required: false },
{ key: 'role', label: '角色', required: false },
],
classTeachers: [
@@ -72,7 +71,8 @@ const KIND_HINTS: Record<Kind, string> = {
grades: '按**学号**匹配本班学生;同一学生 + 科目 + 考试重复导入会覆盖旧分数。',
students:
'按**学号**去重;只生成班级名单,**不创建任何账号**(学生没有密码、不能登录)。班级列可留空,用上一步选的班级。',
teachers: '按**工号**去重;工号就是登录名。',
teachers:
'按**工号**去重;工号就是登录名。新教师分别生成随机密码,导入后请保存密码清单;已有账号密码保持不变。',
classTeachers:
'导入「班级 + 科目 + 教师」的任课关系。角色填「班主任」或「科任」;' +
'同一位老师既是班主任又教某一科时,写两条记录即可 —— 系统只保留一个账号,权限自动合并。',
@@ -279,6 +279,26 @@ async function submit(): Promise<void> {
committing.value = false;
}
}
function downloadCredentials(): void {
if (!result.value?.credentials?.length) return;
const cell = (value: string) =>
`"${(/^[=+@\-\t\r]/.test(value) ? `'${value}` : value).replaceAll('"', '""')}"`;
const rows = [
['工号', '姓名', '初始密码'],
...result.value.credentials.map((c) => [c.username, c.name, c.password]),
];
const url = URL.createObjectURL(
new Blob(['\ufeff' + rows.map((row) => row.map(cell).join(',')).join('\r\n')], {
type: 'text/csv;charset=utf-8',
}),
);
const link = document.createElement('a');
link.href = url;
link.download = '教师初始密码.csv';
link.click();
setTimeout(() => URL.revokeObjectURL(url), 1000);
}
</script>
<template>
@@ -396,6 +416,20 @@ async function submit(): Promise<void> {
<span>跳过:{{ result.skipped }}</span>
<span class="bad">失败:{{ result.failed }}</span>
</div>
<template v-if="result.credentials?.length">
<el-alert
type="warning"
:closable="false"
class="mt-8"
title="随机密码仅在本次导入结果中显示,请在关闭前下载并分发给对应教师。"
/>
<el-button class="mt-8" @click="downloadCredentials">下载教师密码清单</el-button>
<el-table :data="result.credentials" size="small" max-height="240" class="mt-8">
<el-table-column prop="username" label="工号" />
<el-table-column prop="name" label="姓名" />
<el-table-column prop="password" label="初始密码" />
</el-table>
</template>
<el-table
v-if="result.errors.length"
:data="result.errors"
-1
View File
@@ -206,7 +206,6 @@ try {
'native/update-helper.cs',
'src/main/client-agent.ts',
'src/main/index.ts',
'src/main/update.ts',
])
report.sourceHashes[file] = sha(path.join(repo, 'packages/desktop-client', file));
fs.mkdirSync(serverDir, { recursive: true });
+176
View File
@@ -0,0 +1,176 @@
/** 在隐藏 Chromium 中验证真实 Vue 组件的圆角、课表布局与提醒,不连接业务服务。 */
import fs from 'node:fs';
import path from 'node:path';
import { createRequire } from 'node:module';
import { spawn } from 'node:child_process';
const root = path.resolve('.');
const require = createRequire(path.join(root, 'packages/desktop-client/package.json'));
const { build } = require('esbuild');
const { parse, compileScript, compileStyle } = require('vue/compiler-sfc');
const temp = fs.mkdtempSync(path.join(root, '.cache/island-editor-'));
try {
await build({
stdin: {
resolveDir: root,
contents: `
import {createApp,h,reactive,nextTick} from './packages/desktop-client/node_modules/vue/index.mjs';
import {defaultIslandLayouts,DEFAULT_ISLAND_APPEARANCE} from './packages/shared/dist/index.js';
import Runtime from './packages/desktop-client/src/island/CustomIslandRuntime.vue';
import Reminder from './packages/desktop-client/src/island/LessonReminderContent.vue';
import Editor from './packages/desktop-client/src/renderer/views/settings/IslandEditorView.vue';
import Settings from './packages/desktop-client/src/renderer/views/settings/IslandSettingsView.vue';
import ElementPlus from './packages/desktop-client/node_modules/element-plus/es/index.mjs';
import * as icons from './packages/desktop-client/node_modules/@element-plus/icons-vue/dist/index.js';
import './packages/desktop-client/node_modules/element-plus/dist/index.css';
import './packages/ui/src/theme.css';
import './packages/desktop-client/src/island/custom-runtime.css';
(async()=>{
const now=new Date(); now.setHours(9,39,59,0);
const state=reactive({mode:'hidden',active:null,queued:[],inClass:true,currentPeriodEnd:null,reason:null,listExpanded:false,updatedAt:0});
const settings=reactive(defaultIslandLayouts());settings.layout='custom';
const scheme=settings.schemes[0];scheme.radius=0;
scheme.rows[0].nodes=scheme.rows[0].nodes.filter(n=>n.kind==='schedule');
scheme.rows[0].nodes[0].settings.display='all';scheme.rows[0].nodes[0].settings.count=20;
const points=[['a','08:00','08:40',''],['b','09:00','09:40','信息技术'],['c','10:00','10:40','历史']].map(([id,startTime,endTime,courseName])=>({id,startTime,endTime,courseName,timeType:'LESSON',name:'',isHideDefault:false}));
const appearance={...DEFAULT_ISLAND_APPEARANCE,animations:false};
const originalNow=Date.now;Date.now=()=>now.getTime();
window.island={setHitRect(){},reportResidentControl(){},reportSize(){},sendAction(){},onViewport(){return ()=>{}}};
const root=document.createElement('div');document.body.append(root);
const app=createApp({render:()=>h(Runtime,{settings,state,schedules:[],timePoints:points,appearance,nativeVisible:true})});app.mount(root);
const results=[];const check=(name,ok,detail='')=>results.push({name,ok,detail});
const settle=async()=>{await nextTick();await new Promise(r=>setTimeout(r,100));await nextTick()};
await settle();
const card=()=>root.querySelector('.resident-card');
const before=card().style.getPropertyValue('--resident-radius');scheme.radius=14;await settle();
check('修改圆角无需改变内容尺寸即可生效',card().style.getPropertyValue('--resident-radius')==='14px',before+' → '+card().style.getPropertyValue('--resident-radius'));
const lines=[...root.querySelectorAll('.resident-compact .lesson-line')];
const ys=lines.map(n=>{const b=n.getBoundingClientRect();return b.y+b.height/2});
check('全天课表的课程和占位符垂直居中对齐',ys.length===3&&Math.max(...ys)-Math.min(...ys)<1,JSON.stringify(ys));
state.lessonReminder={id:'ending',kind:'ending',courseName:'信息技术',startTime:'09:00',endTime:'09:40',startedAt:now.getTime(),maskUntil:now.getTime()+3000,endsAt:now.getTime()+1000,lessonStartsAt:now.getTime()-2399000,lessonEndsAt:now.getTime()+1000};await settle();
const badge=root.querySelector('.resident-compact .lesson-ending-badge');
check('自定义岛保留课表,在当前课程右侧显示蓝色负数秒倒计时',badge?.textContent.trim()==='-1'&&Number(card().style.getPropertyValue('--resident-scale'))>0,badge?.textContent??'无徽标');
check('临近下课保留常驻内容的可见性',Number(root.querySelector('.resident-compact-page').style.opacity)>0.99);
const reminderRoot=document.createElement('div');document.body.append(reminderRoot);
const reminderApp=createApp({render:()=>h(Reminder,{reminder:state.lessonReminder,now:now.getTime(),appearance,motion:false})});reminderApp.mount(reminderRoot);await settle();
check('经典岛临近下课不显示遮罩和整条文字倒计时',!reminderRoot.querySelector('.ci-mask-active')&&reminderRoot.querySelector('.lesson-ending-badge')?.textContent.trim()==='-1');
reminderApp.unmount();app.unmount();Date.now=originalNow;
const stored={islandLayout:defaultIslandLayouts(),island:appearance};stored.islandLayout.layout='custom';stored.islandLayout.schemes[0].radius=12;
window.desktop={getConfig:async()=>structuredClone(stored),saveConfig:async(patch)=>{Object.assign(stored,patch);return structuredClone(stored)},islandGetAppearance:async()=>appearance,islandSetAppearance(){}};
function mount(Component){const el=document.createElement('div');document.body.append(el);const app=createApp(Component);app.use(ElementPlus);for(const [name,icon]of Object.entries(icons))app.component(name,icon);app.mount(el);return {app,el}};
const editor=mount(Editor);await settle();
check('组件库移除消息选项与编辑提示',editor.el.querySelector('.library-item')&&!editor.el.querySelector('.message-options,.editor-tip,[data-library-kind="notification"],[data-library-kind="homework"],[data-library-kind="call"]')&&!editor.el.textContent.includes('班级消息'));
const palette=[];
for(const dark of [false,true]){
document.documentElement.classList.toggle('dark',dark);await settle();
const page=editor.el.querySelector('.island-editor-page'),button=editor.el.querySelector('.library-item');
const sample=document.createElement('span');page.append(sample);sample.style.background='var(--ch-bg)';
const background=getComputedStyle(page).backgroundColor;
check((dark?'深色':'浅色')+'编辑页与共享主题配色一致',background===getComputedStyle(sample).backgroundColor);
sample.style.background='var(--ch-surface)';
check((dark?'深色':'浅色')+'组件按钮复用共享控件背景',getComputedStyle(button).backgroundColor===getComputedStyle(sample).backgroundColor);
palette.push(background);sample.remove();
}
check('深浅模式切换后同步更新编辑器颜色',palette[0]!==palette[1]);
editor.app.unmount();editor.el.remove();document.documentElement.classList.remove('dark');
const settingsView=mount(Settings);await settle();
const radiusItem=[...settingsView.el.querySelectorAll('.el-form-item')].find(el=>el.querySelector('.el-form-item__label')?.textContent.startsWith('圆角'));
const slider=radiusItem.querySelector('[role="slider"]');slider.dispatchEvent(new KeyboardEvent('keydown',{key:'ArrowRight',code:'ArrowRight',bubbles:true}));await settle();
check('外观页的圆角滑块写入当前自定义方案',stored.islandLayout.schemes[0].radius===13,String(stored.islandLayout.schemes[0].radius));
settingsView.app.unmount();settingsView.el.remove();window.__results=results;
})().catch(error=>{window.__results=[{name:'组件运行',ok:false,detail:error.stack}]});
`,
},
outfile: path.join(temp, 'test.js'),
bundle: true,
format: 'iife',
platform: 'browser',
define: {
'process.env.NODE_ENV': '"test"',
__VUE_OPTIONS_API__: 'true',
__VUE_PROD_DEVTOOLS__: 'false',
__VUE_PROD_HYDRATION_MISMATCH_DETAILS__: 'false',
},
plugins: [
{
name: '真实Vue组件',
setup(b) {
b.onResolve({ filter: /^vue-router$/ }, () => ({ path: 'router', namespace: 'island-test' }));
b.onResolve({ filter: /island\/bridge\.js$/ }, () => ({
path: 'bridge',
namespace: 'island-test',
}));
b.onLoad({ filter: /.*/, namespace: 'island-test' }, (a) => ({
contents:
a.path === 'router'
? 'export const useRouter=()=>({push:async()=>{}});export function onBeforeRouteLeave(){}'
: 'export const getIslandSchedules=()=>[];export const getIslandTimePoints=()=>[];',
loader: 'js',
}));
b.onLoad({ filter: /\.vue$/ }, (args) => {
const source = fs.readFileSync(args.path, 'utf8');
const { descriptor } = parse(source, { filename: args.path });
const id = 'test-' + Buffer.from(path.relative(root, args.path)).toString('hex');
let code = compileScript(descriptor, {
id,
inlineTemplate: true,
genDefaultAs: '__component',
}).content;
if (descriptor.styles.some((s) => s.scoped))
code += `\n__component.__scopeId=${JSON.stringify('data-v-' + id)};`;
for (const style of descriptor.styles) {
const css = style.src
? fs.readFileSync(path.resolve(path.dirname(args.path), style.src), 'utf8')
: style.content;
const compiled = compileStyle({
source: css,
filename: args.path,
id: 'data-v-' + id,
scoped: style.scoped,
}).code;
code += `\n{const s=document.createElement('style');s.textContent=${JSON.stringify(compiled)};document.head.append(s);}`;
}
return {
contents: code + '\nexport default __component;',
loader: 'ts',
resolveDir: path.dirname(args.path),
};
});
},
},
],
logLevel: 'silent',
});
fs.writeFileSync(
path.join(temp, 'test.html'),
'<html><head><meta http-equiv="Content-Security-Policy" content="default-src \'self\'; script-src \'self\'; style-src \'self\' \'unsafe-inline\'; img-src \'self\' data:"><link rel="stylesheet" href="test.css"></head><body><script src="test.js"></script></body></html>',
);
fs.writeFileSync(
path.join(temp, 'main.cjs'),
`
const {app,BrowserWindow}=require('electron');
app.whenReady().then(async()=>{const w=new BrowserWindow({show:false,width:1200,height:800,webPreferences:{backgroundThrottling:false}});
w.webContents.on('console-message',(_e,...a)=>console.log(...a));
try{await w.loadFile(${JSON.stringify(path.join(temp, 'test.html'))});
let results;for(let i=0;i<100;i++){results=await w.webContents.executeJavaScript('window.__results');if(results)break;await new Promise(r=>setTimeout(r,100))}
if(!results)throw Error('组件验证未完成');
for(const r of results)console.log((r.ok?'✓ ':'✗ ')+r.name+' '+r.detail);
app.exit(results.some(r=>!r.ok)?1:0);
}catch(e){console.error(e);app.exit(1)}
});`,
);
const env = { ...process.env };
delete env.ELECTRON_RUN_AS_NODE;
const code = await new Promise((resolve, reject) => {
const p = spawn(require('electron'), [path.join(temp, 'main.cjs')], {
env,
windowsHide: true,
stdio: 'inherit',
});
p.on('error', reject);
p.on('exit', resolve);
});
if (code !== 0) process.exitCode = 1;
} finally {
if (path.dirname(temp) !== path.join(root, '.cache')) throw new Error('拒绝清理工作区外路径');
fs.rmSync(temp, { recursive: true, force: true });
}
+143
View File
@@ -0,0 +1,143 @@
/** 登录保护与两端错误提示回归;仅使用本机临时 HTTP 服务与隔离依赖。 */
import assert from 'node:assert/strict';
import fs from 'node:fs';
import path from 'node:path';
import { createRequire } from 'node:module';
const root = path.resolve('.');
const require = createRequire(path.join(root, 'packages/server/package.json'));
const { build } = createRequire(path.join(root, 'packages/desktop-client/package.json'))('esbuild');
const express = require('express');
const temp = fs.mkdtempSync(path.join(root, '.cache/panel-security-'));
let failed = 0;
async function check(name, test) {
try {
await test();
console.log(`✓ ${name}`);
} catch (error) {
failed++;
console.error(`✗ ${name}: ${error.message}`);
}
}
async function bundle(name, entry, mocks) {
const outfile = path.join(temp, `${name}.cjs`);
await build({
entryPoints: [entry],
outfile,
bundle: true,
platform: 'node',
format: 'cjs',
plugins: [
{
name: '隔离依赖',
setup(b) {
b.onResolve({ filter: /.*/ }, (a) =>
Object.hasOwn(mocks, a.path) ? { path: a.path, namespace: 'mock' } : undefined,
);
b.onLoad({ filter: /.*/, namespace: 'mock' }, (a) => ({ contents: mocks[a.path], loader: 'js' }));
},
},
],
});
return require(outfile);
}
try {
const security = await bundle('security', 'packages/server/src/middleware/security.ts', {
'../config/env.js': 'export const env={rateLimitEnabled:true,isProduction:false};',
'../lib/logger.js': 'export const logger={warn(){}};',
});
const app = express();
app.use(express.json());
app.use(['/login', '/class-login'], security.loginRateLimiter());
app.post(['/login', '/class-login'], (req, res) =>
res.status(req.body.ok ? 200 : 401).json({ message: req.body.ok ? '登录成功' : '账号或密码错误' }),
);
const server = app.listen(0, '127.0.0.1');
await new Promise((r) => server.once('listening', r));
const send = async (ok = false, route = '/login') =>
fetch(`http://127.0.0.1:${server.address().port}${route}`, {
method: 'POST',
headers: { 'content-type': 'application/json' },
body: JSON.stringify({ ok }),
});
const realNow = Date.now;
let now = realNow();
Date.now = () => now;
try {
await check('连续失败五次后,员工与班级登录共用五分钟封禁', async () => {
for (let i = 0; i < 5; i++)
assert.equal((await send(false, i % 2 ? '/class-login' : '/login')).status, 401);
now += 299_000;
const blocked = await send(true);
assert.equal(blocked.status, 429);
assert.ok(Number(blocked.headers.get('retry-after')) > 0);
now += 1001;
assert.equal((await send(true)).status, 200);
});
await check('成功登录清除连续失败次数', async () => {
for (let i = 0; i < 4; i++) assert.equal((await send()).status, 401);
assert.equal((await send(true)).status, 200);
for (let i = 0; i < 4; i++) assert.equal((await send()).status, 401);
assert.equal((await send(true)).status, 200);
});
await check('封禁从第五次失败起完整持续五分钟', async () => {
for (let i = 0; i < 4; i++) await send();
now += 240_000;
await send();
now += 60_001;
assert.equal((await send(true)).status, 429);
now += 240_000;
assert.equal((await send(true)).status, 200);
});
} finally {
Date.now = realNow;
await new Promise((r) => server.close(r));
}
for (const side of ['web-admin', 'desktop-client']) {
const seen = { messages: [], expired: 0, cleared: 0 };
globalThis.__panelSecurity = seen;
globalThis.localStorage = { getItem: () => null, removeItem: () => seen.cleared++ };
globalThis.window = { location: { pathname: '/login', assign: () => seen.expired++ } };
const mod = await bundle(
side,
`packages/${side}/src/${side === 'web-admin' ? '' : 'renderer/'}api/http.ts`,
{
axios:
'const h=globalThis.__panelSecurity; export default {create:()=>({interceptors:{request:{use(){}},response:{use(_ok,fail){h.reject=fail}}}})};',
'element-plus':
'const h=globalThis.__panelSecurity;export const ElMessage={error:m=>h.messages.push(m),warning:m=>h.messages.push(m)};',
'@classhelper/shared': 'export const STORAGE_KEYS={token:"token",user:"user"};',
'@/config': 'export const API_BASE_URL="http://127.0.0.1/api";',
'@/composables/calendarCache': 'export function clearCalendarCache(){}',
'@/composables/assistantRequests': 'export function allowsAiExecution(){return true}',
'../config.js': 'export function apiBaseOf(){return ""}',
},
);
mod.setUnauthorizedHandler?.(() => seen.expired++);
await check(`${side} 密码错误直接显示接口原因,不清会话`, async () => {
await seen
.reject({
config: { url: '/auth/login', method: 'post' },
response: { status: 401, data: { message: '账号或密码错误' } },
})
.catch(() => {});
assert.deepEqual(seen.messages, ['账号或密码错误']);
assert.equal(seen.expired + seen.cleared, 0);
});
seen.messages = [];
await check(`${side} 受保护接口401仍清理过期会话`, async () => {
await seen
.reject({
config: { url: '/auth/me', method: 'get' },
response: { status: 401, data: { message: '凭据过期' } },
})
.catch(() => {});
assert.deepEqual(seen.messages, ['登录状态已失效,请重新登录']);
assert.ok(seen.expired + seen.cleared > 0);
});
}
} finally {
assert.equal(path.dirname(temp), path.join(root, '.cache'));
fs.rmSync(temp, { recursive: true, force: true });
delete globalThis.__panelSecurity;
}
if (failed) process.exitCode = 1;
+72 -2
View File
@@ -195,6 +195,31 @@ try {
});
check('导入课表采用班级配置的 30 周', imported.data?.weekEnd === 30);
const className = (await api(`/classes/${a}`, admin)).data.name;
const teacherTemplate = (await api('/imports/template?kind=teachers&format=csv', admin)).data.content;
const templateRows = teacherTemplate
.trim()
.replace(/^\ufeff/, '')
.split(/\r?\n/)
.map((line) => line.split(','));
check(
'教师 CSV 模板删除密码列且示例角色仍正确对齐',
templateRows[0].join(',') === '工号,姓名,手机号,角色' &&
templateRows[1].length === templateRows[0].length &&
templateRows[1].at(-1) === '教师',
);
const templateResponse = await fetch(`${base}/api/imports/template?kind=teachers&format=xlsx`, {
headers: { authorization: `Bearer ${admin}` },
});
const XLSX = createRequire(path.resolve('packages/server/package.json'))('xlsx');
const workbook = XLSX.read(Buffer.from(await templateResponse.arrayBuffer()));
const templateSheet = XLSX.utils.sheet_to_json(workbook.Sheets[workbook.SheetNames[0]], { header: 1 });
check(
'教师 Excel 模板不包含默认密码且列数与示例一致',
templateResponse.ok &&
templateSheet[0].length === templateSheet[1].length &&
!templateSheet[0].includes('初始密码') &&
templateSheet[1].at(-1) === '教师',
);
const relations = await api('/imports/table/commit', admin, {
kind: 'classTeachers',
fileName: 'relations.csv',
@@ -211,6 +236,44 @@ try {
relations.data?.errors.length === 0 &&
relations.data.inserted + relations.data.updated > 0,
);
const randomTeacherNames = [`review_r1_${stamp}`, `review_r2_${stamp}`];
const randomClassName = (await api(`/classes/${b}`, admin)).data.name;
const randomRelations = await api('/imports/table/commit', admin, {
kind: 'classTeachers',
fileName: 'random-relations.csv',
mode: 'upsert',
useTeacherNo: true,
mapping: { className: '班级', subjectName: '科目', teacherNo: '工号', teacherName: '姓名', role: '角色' },
contentBase64: Buffer.from(
`\ufeff班级,科目,工号,姓名,角色\n${randomClassName},随机密码甲,${randomTeacherNames[0]},随机教师甲,科任\n${randomClassName},随机密码乙,${randomTeacherNames[1]},随机教师乙,科任\n${randomClassName},随机密码丙,${randomTeacherNames[0]},随机教师甲,科任`,
).toString('base64'),
});
const relationCredentials = randomRelations.data?.credentials ?? [];
const generatedTeachers = (await api('/teachers', admin)).data.filter((teacher) =>
randomTeacherNames.includes(teacher.username),
);
users.push(...generatedTeachers.map((teacher) => teacher.id));
check(
'任课关系导入为新教师分别生成随机密码且同一工号不重复生成',
randomRelations.status === 200 &&
randomRelations.data?.inserted === 2 &&
relationCredentials.length === 2 &&
new Set(relationCredentials.map((c) => c.password)).size === 2,
);
for (const credential of relationCredentials) {
const login = await api('/auth/login', null, {
username: credential.username,
password: credential.password,
});
check('任课导入的随机密码可用于教师登录', login.status === 200);
}
const relationAudits = (await api('/permissions/audit?pageSize=100', admin)).data.items.filter(
(item) => item.action === 'import-commitClassTeachers',
);
check(
'任课导入审计不存储随机密码或凭据清单',
relationAudits.length > 0 && relationAudits.every((item) => !/password|credentials/.test(item.afterJson)),
);
const csv = `\ufeff学号,姓名,考试,分数\n,同名同学,审查考试,80`;
const importBase = {
kind: 'grades',
@@ -304,6 +367,7 @@ try {
'teacher:read',
'call:create',
'ai:use',
'notification:publish',
'student:grade-query',
'update:check',
];
@@ -343,9 +407,15 @@ try {
(await api('/ai/interpret', staffToken, { classId: b, text: '发布通知测试' })).status === 403,
);
const interpreted = await api('/ai/interpret', staffToken, { classId: a, text: '发布通知,明天带书' });
check('自己的班级可以离线解析', interpreted.status === 200);
check(
'具有业务发布权限时为本班生成离线通知计划',
interpreted.status === 200 && Boolean(interpreted.data?.planId) && interpreted.data?.steps?.length > 0,
);
const audits = (await api('/ai/audit', admin)).data;
check('解析审计使用明确的解析状态', ['interpreted', 'unrecognized'].includes(audits[0]?.status));
check(
'通知计划保留待确认状态,不在解析时执行',
audits.find((item) => item.id === interpreted.data?.planId)?.status === 'pending',
);
check(
'协议相对附件地址不能写入作业',
(
+1 -1
View File
@@ -18,7 +18,7 @@
<!-- 页面上所有版本号与文件名都从这一行起步:脚本会去 GitHub Releases 取真实清单,
取不到时(离线、被限流)就按这份版本号 + 发布命名约定拼直链。
它和根 package.json 一起由 `pnpm version:bump` 维护 —— 别在这儿单独改。 -->
<meta name="ch-version" content="1.4.4" />
<meta name="ch-version" content="1.4.5" />
<link rel="icon" href="assets/icon.png" />
<link rel="apple-touch-icon" href="assets/icon.png" />
+3 -3
View File
@@ -44,7 +44,7 @@
<a class="brand" href="#top" data-press="0.96">
<img class="brand-mark" src="assets/icon.png" alt="" width="32" height="32" />
<span class="brand-name">ClassHelper</span>
<span class="brand-ver">1.4.4</span>
<span class="brand-ver">1.4.5</span>
</a>
<nav class="topnav" aria-label="页内导航">
<span class="nav-pill" aria-hidden="true"></span>
@@ -93,7 +93,7 @@
</div>
<ul class="hero-badges intro-seq" style="--intro-delay: 300ms">
<li>v1.4.4</li>
<li>v1.4.5</li>
<li>Windows 10/11</li>
<li>Linux · Docker</li>
<li>触摸屏可用</li>
@@ -733,7 +733,7 @@
ClassHelper
<span>Class Helper</span>
</p>
<p class="foot-ver">版本 1.4.4 · 源码公开 · 装在你自己的机器上</p>
<p class="foot-ver">版本 1.4.5 · 源码公开 · 装在你自己的机器上</p>
</div>
</div>
<nav class="foot-nav" aria-label="相关链接">