LoveChengke
9d5ac7adf9
学生、任课关系、周次口径三处长期靠约定维持的事情，改为由数据模型保证。 学生不是账号 - 拆出独立 Student 表，没有 passwordHash / role / 任何登录字段 - 「学生不能登录」由表结构保证，不再靠「登录前判 role 再 403」的代码分支 - 三张个人数据表外键 userId → studentId；删掉 Enrollment 与 ClassTeacher - 学生一律称「学号」、教师一律称「工号」，「学生账号」这个概念消失 任课关系唯一来源 = Course（班级 + 科目 + 教师） - 班主任 = Class.teacherId，科任 = Course.teacherId，同一人两处指向同一账号、不重复建号 - 作业与成绩按科目再收一道：挂科目只由该科任课老师改，没挂科目归班主任 / 管理员 - 新增「任课教师分配」与「班级教师批量导入」（带「使用工号匹配」开关） 成绩与名单 - 成绩等级：百分制 / 等级制 A·B·C·D / 自定义，支持单个与批量改等级 - 按学号查成绩明细（教师端 + 班级端 + 设备令牌），受按班开关控制 - 调班 / 转出（单个与批量）+ 可查历史；学号不变、历史作业成绩留原归属 - 毕业归档页（按年度记录毕业班级 / 毕业生 / 转出学生 / 该届通知与作业） - 学年升级（未毕业不归档、数据沿用）；班级称呼改为「2026级1班」 ClassHelper 班级端在线状态 - Web 端显示 班级 / 设备名 / 设备号 / 在线离线 / 最后在线 / 最后心跳 - lastHeartbeatAt 驱动 60 秒在线窗口，与只表示「带状态上报」的 lastSeenAt 分开 学期周次 - 新增 TermWeek（classId 空串 = 全校默认），管理员可用日期范围选择器逐周配置 - 一键按开学日期生成整学期；联网拉取调休建议（只给建议、不改数据，无外网失败属正常） - 改周次后随课表下发给教室的 ClassHelper 班级端 课表方向反转 - 主方向改为「服务端 → 教室」自动下发；教室不再自动回传 - 取教室课表改为手动动作（点击前弹警告），插件按待办标记在下一次心跳补报 改名 - 班级小助手 → ClassHelper：界面、窗口标题、托盘、灵动岛、EXE、安装包、 安装目录、systemd 描述、插件清单与设置页、官网、文档站、README BREAKING CHANGE: 产品名与 EXE 名变更（班级小助手.exe → ClassHelper.exe）， 安装目录随之改变，不支持覆盖安装，需先卸载旧版。 服务端首次启动会自动应用 6 个数据库迁移（学生行按 id 原样搬迁，历史数据不丢）， 升级前请先备份。
680 lines
28 KiB
JavaScript
680 lines
28 KiB
JavaScript
#!/usr/bin/env node
|
||
/**
|
||
* ClassIsland 联动验证（插件侧接口 + 下发链路）。
|
||
*
|
||
* 覆盖范围：
|
||
* 1) 设备令牌鉴权：无令牌 / 错令牌一律 401，令牌作废后立即失效
|
||
* 2) 插件上报 → 服务端写库（课表 + 节次时间 + 状态快照）幂等
|
||
* 3) 教师下发提醒 → 落库 → 插件 pending 拉到 → ack 后不再补发
|
||
* 4) 停用设备后插件上报被 403 拦下
|
||
* 5) 课表镜像拉取（mirrorScheduleToClassIsland）返回 ClassIsland 口径的数据
|
||
*
|
||
* 用法：
|
||
* 1) 另开终端启动后端：pnpm dev:server
|
||
* 2) 执行：node packages/server/scripts/verify-classisland.mjs
|
||
*
|
||
* 环境变量：
|
||
* VERIFY_BASE_URL 默认 http://127.0.0.1:4000（脚本直连，不受系统代理影响）
|
||
*
|
||
* 注意：本脚本只操作「新建设备 + 该设备对应班级」的数据，
|
||
* 结束时会把新建的设备删除；上报的课表会写进该班（与导入模块语义一致，可被覆盖）。
|
||
*/
|
||
const BASE_URL = process.env.VERIFY_BASE_URL ?? `http://127.0.0.1:${process.env.PORT ?? 4000}`;
|
||
|
||
const results = [];
|
||
|
||
function record(name, ok, detail = '') {
|
||
results.push({ name, ok, detail });
|
||
console.log(`${ok ? '\u2713' : '\u2717'} ${name}${detail ? ` (${detail})` : ''}`);
|
||
}
|
||
|
||
async function api(path, { method = 'GET', token, deviceToken, body } = {}) {
|
||
const headers = { 'Content-Type': 'application/json' };
|
||
if (token) headers.Authorization = `Bearer ${token}`;
|
||
if (deviceToken) headers['X-ClassIsland-Token'] = deviceToken;
|
||
const response = await fetch(`${BASE_URL}/api${path}`, {
|
||
method,
|
||
headers,
|
||
body: body === undefined ? undefined : JSON.stringify(body),
|
||
});
|
||
const payload = await response.json().catch(() => null);
|
||
return { status: response.status, payload };
|
||
}
|
||
|
||
/** 造一份插件会上报的课表（周一/周二，含单双周） */
|
||
function sampleSchedule() {
|
||
return {
|
||
mode: 'merge',
|
||
entries: [
|
||
{
|
||
dayOfWeek: 1,
|
||
startTime: '08:00',
|
||
endTime: '08:45',
|
||
subject: '语文',
|
||
teacherName: '王老师',
|
||
weekParity: 'ALL',
|
||
weekCountDiv: 0,
|
||
weekCountDivTotal: 0,
|
||
planName: '周一课表',
|
||
},
|
||
{
|
||
dayOfWeek: 1,
|
||
startTime: '08:55',
|
||
endTime: '09:40',
|
||
subject: '数学',
|
||
teacherName: '李老师',
|
||
weekParity: 'ODD',
|
||
weekCountDiv: 1,
|
||
weekCountDivTotal: 2,
|
||
planName: '周一课表',
|
||
},
|
||
{
|
||
dayOfWeek: 2,
|
||
startTime: '08:00',
|
||
endTime: '08:45',
|
||
subject: '英语',
|
||
teacherName: '张老师',
|
||
weekParity: 'ALL',
|
||
weekCountDiv: 0,
|
||
weekCountDivTotal: 0,
|
||
planName: '周二课表',
|
||
},
|
||
],
|
||
};
|
||
}
|
||
|
||
function sampleTimeLayout() {
|
||
return {
|
||
name: 'ClassIsland 验证时间表',
|
||
mode: 'replace',
|
||
items: [
|
||
{ index: 1, name: '第 1 节', startTime: '08:00', endTime: '08:45', type: 'class', skipped: false },
|
||
{ index: 2, name: '课间', startTime: '08:45', endTime: '08:55', type: 'break', skipped: false },
|
||
{ index: 3, name: '第 2 节', startTime: '08:55', endTime: '09:40', type: 'class', skipped: false },
|
||
],
|
||
};
|
||
}
|
||
|
||
/** 按候选密码依次登录，返回可用 token（不同环境的默认密码可能不同） */
|
||
async function loginWithCandidates(username, passwords) {
|
||
for (const password of passwords) {
|
||
const result = await api('/auth/login', { method: 'POST', body: { username, password } });
|
||
const token = result.payload?.data?.token;
|
||
if (token) return token;
|
||
}
|
||
return null;
|
||
}
|
||
|
||
/**
|
||
* 反复「拉取待提醒 → 逐条确认」，直到该设备视角下没有积压。
|
||
*
|
||
* 为什么验证脚本要做这件事：`GET /integrations/classisland/pending` 是
|
||
* 「本班全部未确认且未过期的提醒，按时间升序取前 20 条」。而 `verify:desktop` /
|
||
* `verify:web` 等冒烟会**真的往演示班发通知**（AGENTS.md §5 第 38 条），
|
||
* 那些条如果没被确认就会一直堆着 —— 攒够 20 条之后，本脚本刚发的提醒会被挤到窗口之外，
|
||
* 表现为「待提醒里找不到刚发的那条」，与代码对不对完全无关（2026-10-05 实测踩过：
|
||
* 库里积了 45 条历次冒烟残条，本脚本从 42/42 掉到 35/40）。
|
||
*
|
||
* 这里做的事情与真实插件重连后的行为完全一致（补弹积压并逐条确认），
|
||
* 因此不会掩盖任何产品侧问题。可见范围也一致：只处理 `deviceId` 为空的班级广播
|
||
* 与本设备自己的推送，别的设备的目标推送取不到、也确认不了。
|
||
*/
|
||
async function drainPending(deviceToken) {
|
||
let total = 0;
|
||
for (let round = 0; round < 20; round += 1) {
|
||
const pending = await api('/integrations/classisland/pending', { deviceToken });
|
||
const items = pending.payload?.data?.notifications ?? [];
|
||
if (items.length === 0) break;
|
||
for (const item of items) {
|
||
await api('/integrations/classisland/ack', { method: 'POST', deviceToken, body: { id: item.id } });
|
||
total += 1;
|
||
}
|
||
}
|
||
return total;
|
||
}
|
||
|
||
async function main() {
|
||
console.log(`\n=== ClassIsland 联动验证（${BASE_URL}）===\n`);
|
||
|
||
const health = await api('/health');
|
||
if (health.status !== 200) {
|
||
console.log('后端未启动，请先运行 pnpm dev:server\n');
|
||
process.exit(1);
|
||
}
|
||
const modules = health.payload?.data?.modules ?? [];
|
||
record('integrations 模块已挂载', modules.includes('integrations'), modules.join(', '));
|
||
if (!modules.includes('integrations')) process.exit(1);
|
||
|
||
// ---------------------------------------------------------------- 登录
|
||
// 演示库里的教师密码由 .env 的 DEFAULT_TEACHER_PASSWORD 决定（种子脚本用它建号），
|
||
// 因此这里按候选列表尝试，避免「换了环境就整脚本失败」。
|
||
const teacherToken = await loginWithCandidates('teacher1', ['teacher123', '123456']);
|
||
record('教师登录 teacher1', Boolean(teacherToken));
|
||
if (!teacherToken) process.exit(1);
|
||
|
||
// 管理员用于取班级码（只有管理员/班主任能看到班级码），学生隔离用例需要它
|
||
const adminToken = await loginWithCandidates('admin', ['admin123']);
|
||
|
||
const classes = await api('/classes', { token: teacherToken });
|
||
const target = (classes.payload?.data ?? [])[0];
|
||
record('取到可管理的班级', Boolean(target?.id), target ? `${target.name} (${target.id})` : '无');
|
||
if (!target?.id) process.exit(1);
|
||
|
||
// 叫人用例需要一位学生；班级账号用来验证"教室客户端自己选显示位置"
|
||
const students = await api(`/classes/${target.id}/students`, { token: teacherToken });
|
||
const firstStudent = (students.payload?.data ?? [])[0];
|
||
|
||
/** 用班级码 + 班级密码登录，拿班级账号 token（教室机器的身份） */
|
||
async function classLoginToken() {
|
||
if (adminToken) {
|
||
const detail = await api(`/classes/${target.id}`, { token: adminToken });
|
||
const code = detail.payload?.data?.code;
|
||
if (code) {
|
||
for (const password of ['123456', 'class123']) {
|
||
const result = await api('/auth/class-login', {
|
||
method: 'POST',
|
||
body: { code, password },
|
||
});
|
||
const token = result.payload?.data?.token;
|
||
if (token) return token;
|
||
}
|
||
}
|
||
}
|
||
return null;
|
||
}
|
||
|
||
// ---------------------------------------------------------------- 1. 新建设备
|
||
const created = await api('/integrations/devices', {
|
||
method: 'POST',
|
||
token: teacherToken,
|
||
body: { classId: target.id, name: '验证用设备', syncScheduleToServer: true },
|
||
});
|
||
const deviceToken = created.payload?.data?.token;
|
||
const deviceId = created.payload?.data?.device?.id;
|
||
record(
|
||
'新建设备并返回设备令牌',
|
||
created.status === 201 && typeof deviceToken === 'string' && deviceToken.startsWith('chci_'),
|
||
`status=${created.status} hint=${created.payload?.data?.device?.tokenHint ?? '-'}`,
|
||
);
|
||
if (!deviceToken || !deviceId) process.exit(1);
|
||
|
||
// ---------------------------------------------------------------- 2. 令牌鉴权
|
||
const noToken = await api('/integrations/classisland/report', { method: 'POST', body: {} });
|
||
record('无令牌上报被拒（401）', noToken.status === 401, `status=${noToken.status}`);
|
||
const badToken = await api('/integrations/classisland/report', {
|
||
method: 'POST',
|
||
deviceToken: 'chci_deadbeef',
|
||
body: {},
|
||
});
|
||
record('错误令牌上报被拒（401）', badToken.status === 401, `status=${badToken.status}`);
|
||
|
||
// ---------------------------------------------------------------- 3. 上报（状态 + 课表 + 节次）
|
||
const reportBody = {
|
||
pluginVersion: '1.1.2.0',
|
||
classIslandVersion: '2.1.0.0',
|
||
state: {
|
||
inClass: true,
|
||
subject: '语文',
|
||
nextSubject: '数学',
|
||
timeState: 'OnClass',
|
||
periodStart: '08:00',
|
||
periodEnd: '08:45',
|
||
week: 1,
|
||
classPlanLoaded: true,
|
||
clientTime: new Date().toISOString(),
|
||
},
|
||
schedule: sampleSchedule(),
|
||
timeLayout: sampleTimeLayout(),
|
||
};
|
||
const report1 = await api('/integrations/classisland/report', {
|
||
method: 'POST',
|
||
deviceToken,
|
||
body: reportBody,
|
||
});
|
||
const r1 = report1.payload?.data;
|
||
record(
|
||
'插件上报课表写入成功',
|
||
report1.status === 200 && r1?.scheduleApplied === true && r1.scheduleCreated + r1.scheduleUpdated === 3,
|
||
`新增=${r1?.scheduleCreated} 更新=${r1?.scheduleUpdated} 周=${r1?.week}`,
|
||
);
|
||
record('插件上报节次时间写入成功', r1?.timeLayoutApplied === true, `applied=${r1?.timeLayoutApplied}`);
|
||
record('上报回传服务端周次与时间', typeof r1?.serverTime === 'string' && Number.isInteger(r1?.week));
|
||
|
||
// 幂等：重复上报不应产生重复行
|
||
const report2 = await api('/integrations/classisland/report', {
|
||
method: 'POST',
|
||
deviceToken,
|
||
body: reportBody,
|
||
});
|
||
const r2 = report2.payload?.data;
|
||
record(
|
||
'重复上报幂等（不新增、只更新）',
|
||
r2?.scheduleCreated === 0 && r2?.scheduleUpdated === 3,
|
||
`新增=${r2?.scheduleCreated} 更新=${r2?.scheduleUpdated}`,
|
||
);
|
||
|
||
// 设备列表里的状态快照
|
||
const devices = await api(`/integrations/devices?classId=${target.id}`, { token: teacherToken });
|
||
const listed = (devices.payload?.data ?? []).find((item) => item.id === deviceId);
|
||
record(
|
||
'设备状态快照已更新（Web 端可展示）',
|
||
Boolean(listed?.lastSeenAt) &&
|
||
listed?.currentSubject === '语文' &&
|
||
listed?.currentTimeState === 'OnClass',
|
||
`科目=${listed?.currentSubject} 状态=${listed?.currentTimeState} ClassIsland=${listed?.classIslandVersion}`,
|
||
);
|
||
|
||
// ---------------------------------------------------------------- 4. 下发提醒
|
||
// 先确认掉本班的历史积压（历次冒烟留下的未确认提醒），否则 /pending 的前 20 条窗口
|
||
// 会被它们占满，下面「插件拉取到待提醒」等用例会拿不到刚发的这条（理由见 drainPending）
|
||
const drained = await drainPending(deviceToken);
|
||
if (drained > 0) {
|
||
console.log(`（已确认本班 ${drained} 条历史积压提醒，避免挤占待提醒窗口）\n`);
|
||
}
|
||
|
||
const notify = await api('/integrations/classisland/notify', {
|
||
method: 'POST',
|
||
token: teacherToken,
|
||
body: {
|
||
classId: target.id,
|
||
title: '请到讲台领资料',
|
||
content: '下课后来讲台领取期中复习资料',
|
||
durationSeconds: 12,
|
||
speech: true,
|
||
},
|
||
});
|
||
const n1 = notify.payload?.data;
|
||
record(
|
||
'教师下发提醒（落库 + 标记设备数）',
|
||
notify.status === 200 && n1?.targetCount >= 1 && Boolean(n1?.notificationId),
|
||
`设备数=${n1?.targetCount} 通知id=${n1?.notificationId ? '有' : '无'}`,
|
||
);
|
||
|
||
const pending = await api('/integrations/classisland/pending', { deviceToken });
|
||
const items = pending.payload?.data?.notifications ?? [];
|
||
const picked = items.find((item) => item.title === '请到讲台领资料');
|
||
record(
|
||
'插件拉取到待提醒（离线补齐链路可用）',
|
||
pending.status === 200 && Boolean(picked),
|
||
`待提醒数=${items.length} 时长=${picked?.durationSeconds}s 朗读=${Boolean(picked?.speechContent)}`,
|
||
);
|
||
|
||
if (picked) {
|
||
const ack = await api('/integrations/classisland/ack', {
|
||
method: 'POST',
|
||
deviceToken,
|
||
body: { id: picked.id },
|
||
});
|
||
record(
|
||
'插件确认提醒已弹出',
|
||
ack.status === 200 && ack.payload?.data?.acked === true,
|
||
`status=${ack.status}`,
|
||
);
|
||
const pending2 = await api('/integrations/classisland/pending', { deviceToken });
|
||
const again = (pending2.payload?.data?.notifications ?? []).some((item) => item.id === picked.id);
|
||
record('确认后不再补发（避免重复弹窗）', !again, `仍在待提醒中=${again}`);
|
||
}
|
||
|
||
// ---------------------------------------------------------------- 4.5 其他发布入口也会联动 ClassIsland
|
||
// 需求："在其他页面发通知也可以联动 ClassIsland"。通知发布页 / 叫人走的是各自的接口，
|
||
// 这里逐个验证它们真的会生成待弹出提醒（而不是只有联动页那个专用接口才联动）。
|
||
const classChannel = await api(`/classes/${target.id}/notification-channel`, { token: teacherToken });
|
||
record(
|
||
'班级有"通知显示位置"（默认两端都弹）',
|
||
classChannel.status === 200 && classChannel.payload?.data?.notificationChannel === 'both',
|
||
`channel=${classChannel.payload?.data?.notificationChannel}`,
|
||
);
|
||
|
||
const published = await api('/notifications', {
|
||
method: 'POST',
|
||
token: teacherToken,
|
||
body: { classId: target.id, title: '通知页联动验证', content: '从通知发布页发的通知', priority: 'NORMAL' },
|
||
});
|
||
const pendingAfterPublish = await api('/integrations/classisland/pending', { deviceToken });
|
||
const publishPush = (pendingAfterPublish.payload?.data?.notifications ?? []).find(
|
||
(item) => item.title === '通知页联动验证',
|
||
);
|
||
record(
|
||
'通知发布页发的通知也会推送到 ClassIsland',
|
||
published.status === 201 && Boolean(publishPush),
|
||
`status=${published.status} 待提醒=${(pendingAfterPublish.payload?.data?.notifications ?? []).length}`,
|
||
);
|
||
// kind 决定插件"上课时段弹不弹"：通知类会被暂存，叫人属于主动通知要立刻弹
|
||
record(
|
||
'通知类推送的 kind=notification（上课时段插件会暂存）',
|
||
publishPush?.kind === 'notification',
|
||
`kind=${publishPush?.kind}`,
|
||
);
|
||
if (publishPush) {
|
||
await api('/integrations/classisland/ack', {
|
||
method: 'POST',
|
||
deviceToken,
|
||
body: { id: publishPush.id },
|
||
});
|
||
}
|
||
|
||
const call = await api('/calls', {
|
||
method: 'POST',
|
||
token: teacherToken,
|
||
body: { classId: target.id, studentId: firstStudent?.id, message: '叫人联动验证' },
|
||
});
|
||
const pendingAfterCall = await api('/integrations/classisland/pending', { deviceToken });
|
||
const callPush = (pendingAfterCall.payload?.data?.notifications ?? []).find(
|
||
(item) => item.content === '叫人联动验证',
|
||
);
|
||
record(
|
||
'叫人也会推送到 ClassIsland',
|
||
Boolean(firstStudent) && call.status === 201 && Boolean(callPush),
|
||
firstStudent ? `status=${call.status}` : '班级里没有学生，跳过',
|
||
);
|
||
record(
|
||
'叫人推送的 kind=call（算主动通知，上课时段也立刻弹）',
|
||
callPush?.kind === 'call',
|
||
`kind=${callPush?.kind}`,
|
||
);
|
||
if (callPush) {
|
||
await api('/integrations/classisland/ack', {
|
||
method: 'POST',
|
||
deviceToken,
|
||
body: { id: callPush.id },
|
||
});
|
||
}
|
||
|
||
// 教室在客户端里选"只在 ClassHelper 客户端显示"后，任何入口都不该再打扰 ClassIsland
|
||
const setClient = await api(`/classes/${target.id}/notification-channel`, {
|
||
method: 'PATCH',
|
||
token: teacherToken,
|
||
body: { notificationChannel: 'client' },
|
||
});
|
||
record(
|
||
'可把"通知显示位置"改成只在客户端显示',
|
||
setClient.status === 200 && setClient.payload?.data?.notificationChannel === 'client',
|
||
`channel=${setClient.payload?.data?.notificationChannel}`,
|
||
);
|
||
|
||
const mutedPublish = await api('/notifications', {
|
||
method: 'POST',
|
||
token: teacherToken,
|
||
body: { classId: target.id, title: '不该上 ClassIsland 的通知', content: '教室选择了只在客户端显示' },
|
||
});
|
||
const mutedNotify = await api('/integrations/classisland/notify', {
|
||
method: 'POST',
|
||
token: teacherToken,
|
||
body: { classId: target.id, title: '联动页也不该下发', content: '同样被教室的设置拦下' },
|
||
});
|
||
const pendingMuted = await api('/integrations/classisland/pending', { deviceToken });
|
||
const mutedItems = pendingMuted.payload?.data?.notifications ?? [];
|
||
record(
|
||
'显示位置=client 时通知不再推送 ClassIsland',
|
||
mutedPublish.status === 201 && !mutedItems.some((item) => item.title === '不该上 ClassIsland 的通知'),
|
||
`待提醒=${mutedItems.length}`,
|
||
);
|
||
record(
|
||
'显示位置=client 时联动页的下发也会被跳过（并说明原因）',
|
||
mutedNotify.status === 200 &&
|
||
mutedNotify.payload?.data?.skipped === 'channel-client' &&
|
||
String(mutedNotify.payload?.message ?? '').includes('只在 ClassHelper 客户端显示'),
|
||
`skipped=${mutedNotify.payload?.data?.skipped} message=${mutedNotify.payload?.message}`,
|
||
);
|
||
|
||
// 班级账号（教室机器）自己就能读写这项设置 —— 需求就是"由 ClassIsland 之外的客户端自己选"
|
||
const classSessionToken = await classLoginToken();
|
||
const readByClass = await api(`/classes/${target.id}/notification-channel`, {
|
||
token: classSessionToken,
|
||
});
|
||
record(
|
||
'班级账号可读取通知显示位置',
|
||
readByClass.status === 200 && readByClass.payload?.data?.notificationChannel === 'client',
|
||
`channel=${readByClass.payload?.data?.notificationChannel}`,
|
||
);
|
||
const setByClass = await api(`/classes/${target.id}/notification-channel`, {
|
||
method: 'PATCH',
|
||
token: classSessionToken,
|
||
body: { notificationChannel: 'both' },
|
||
});
|
||
record(
|
||
'班级账号可修改通知显示位置（由教室客户端自己选）',
|
||
setByClass.status === 200 && setByClass.payload?.data?.notificationChannel === 'both',
|
||
`channel=${setByClass.payload?.data?.notificationChannel}`,
|
||
);
|
||
const badChannel = await api(`/classes/${target.id}/notification-channel`, {
|
||
method: 'PATCH',
|
||
token: teacherToken,
|
||
body: { notificationChannel: 'nope' },
|
||
});
|
||
record('非法显示位置被拒（422）', badChannel.status === 422, `status=${badChannel.status}`);
|
||
|
||
// ---------------------------------------------------------------- 5. 课表镜像
|
||
//
|
||
// 同步方向在 2026-10-06 反转：**服务端 → 教室自动下发**成为主方向（默认开启），
|
||
// 「把教室课表传上来」改成 Web 端的一次性人工动作。因此这里先验证"默认就下发"，
|
||
// 再验证"关掉之后确实不下发"。
|
||
const mirrorDefault = await api('/integrations/classisland/class-plan', { deviceToken });
|
||
record(
|
||
'课表默认由服务端自动下发（新方向：服务端 → 教室）',
|
||
mirrorDefault.status === 200 && mirrorDefault.payload?.data?.classPlan?.entries?.length >= 0,
|
||
`status=${mirrorDefault.status} data=${mirrorDefault.payload?.data === null ? 'null' : 'object'}`,
|
||
);
|
||
|
||
const disabled = await api(`/integrations/devices/${deviceId}`, {
|
||
method: 'PATCH',
|
||
token: teacherToken,
|
||
body: { mirrorScheduleToClassIsland: false },
|
||
});
|
||
record(
|
||
'关闭「镜像课表到 ClassIsland」',
|
||
disabled.status === 200 && disabled.payload?.data?.mirrorScheduleToClassIsland === false,
|
||
`status=${disabled.status}`,
|
||
);
|
||
|
||
const mirrorOff = await api('/integrations/classisland/class-plan', { deviceToken });
|
||
record(
|
||
'关掉镜像后不再下发课表',
|
||
mirrorOff.status === 200 &&
|
||
(mirrorOff.payload?.data === null || mirrorOff.payload?.data === undefined),
|
||
`data=${mirrorOff.payload?.data === null ? 'null' : 'object'}`,
|
||
);
|
||
|
||
const enabled = await api(`/integrations/devices/${deviceId}`, {
|
||
method: 'PATCH',
|
||
token: teacherToken,
|
||
body: { mirrorScheduleToClassIsland: true },
|
||
});
|
||
record(
|
||
'重新打开「镜像课表到 ClassIsland」',
|
||
enabled.status === 200 && enabled.payload?.data?.mirrorScheduleToClassIsland === true,
|
||
`status=${enabled.status}`,
|
||
);
|
||
|
||
const mirror = await api('/integrations/classisland/class-plan', { deviceToken });
|
||
const plan = mirror.payload?.data?.classPlan;
|
||
const weekDays = (plan?.entries ?? []).map((item) => item.weekDay);
|
||
record(
|
||
'拉取课表为 ClassIsland 口径（0=周日 … 6=周六）',
|
||
mirror.status === 200 &&
|
||
Array.isArray(plan?.entries) &&
|
||
plan.entries.length >= 3 &&
|
||
weekDays.every((day) => day >= 0 && day <= 6),
|
||
`条目=${plan?.entries?.length} weekDay=[${weekDays.join(',')}] 档案名=${plan?.profileName}`,
|
||
);
|
||
record(
|
||
'单双周换算为 WeekCountDiv/Total',
|
||
(plan?.entries ?? []).some((item) => item.weekCountDivTotal === 2),
|
||
(plan?.entries ?? [])
|
||
.map((item) => `${item.subject}:${item.weekCountDiv}/${item.weekCountDivTotal}`)
|
||
.join(' '),
|
||
);
|
||
// ClassInfo.Index 与"第 i 个上课时间点"一一对应，因此镜像条目必须带起止时间，
|
||
// 否则插件只能按数组顺序硬排，一旦某天少一节整份课表就错位（这是最容易漏的一处契约）
|
||
const timeOk = (plan?.entries ?? []).every(
|
||
(item) => /^\d{2}:\d{2}$/.test(item.startTime ?? '') && /^\d{2}:\d{2}$/.test(item.endTime ?? ''),
|
||
);
|
||
record(
|
||
'镜像条目带起止时间（插件据此重建上课时间点）',
|
||
(plan?.entries ?? []).length > 0 && timeOk,
|
||
(plan?.entries ?? [])
|
||
.slice(0, 3)
|
||
.map((item) => `${item.subject} ${item.startTime}-${item.endTime}`)
|
||
.join(' | '),
|
||
);
|
||
const classPoints = (plan?.timeLayouts?.[0]?.layouts ?? []).filter((item) => item.timeType === 0);
|
||
record(
|
||
'镜像时间表含上课时间点（与课表条目对得上）',
|
||
classPoints.length > 0 && (plan?.entries ?? []).length >= classPoints.length / 2,
|
||
`上课点=${classPoints.length} 条目=${(plan?.entries ?? []).length}`,
|
||
);
|
||
|
||
/* ---------------------------------------------------------------- 5.1 课表同步：幽灵行清理 + 机器码回填 */
|
||
// 老师在 Web 端手排的一节课（source=manual）：插件同步时**绝不能**删它
|
||
const courseList = await api(`/courses?classId=${target.id}`, { token: teacherToken });
|
||
const courseId = (courseList.payload?.data ?? [])[0]?.id;
|
||
const manualCreated = await api('/schedules', {
|
||
method: 'POST',
|
||
token: teacherToken,
|
||
body: {
|
||
classId: target.id,
|
||
courseId,
|
||
dayOfWeek: 7,
|
||
startTime: '21:00',
|
||
endTime: '21:45',
|
||
weekStart: 1,
|
||
weekEnd: 20,
|
||
weekParity: 'ALL',
|
||
},
|
||
});
|
||
const manualScheduleId = manualCreated.payload?.data?.id;
|
||
record(
|
||
'（准备）Web 端手排一节课（source=manual）',
|
||
manualCreated.status === 201 && Boolean(manualScheduleId),
|
||
`status=${manualCreated.status}`,
|
||
);
|
||
|
||
const entry = (startTime, endTime) => ({
|
||
dayOfWeek: 6,
|
||
startTime,
|
||
endTime,
|
||
subject: '语文',
|
||
weekParity: 'ALL',
|
||
});
|
||
|
||
/** 该班课表里"周六 19:xx"的行（插件上报写入的那些） */
|
||
const listSaturday = async () => {
|
||
const list = await api(`/schedules?classId=${target.id}`, { token: teacherToken });
|
||
return (list.payload?.data ?? []).filter(
|
||
(item) => item.dayOfWeek === 6 && item.startTime.startsWith('19:'),
|
||
);
|
||
};
|
||
|
||
// 第一次上报：两节（第二节随后会被"老师在 ClassIsland 里删掉"）
|
||
const ghostReport = await api('/integrations/classisland/report', {
|
||
method: 'POST',
|
||
deviceToken,
|
||
body: {
|
||
deviceKey: 'smoke-machine-01',
|
||
schedule: { mode: 'merge', entries: [entry('19:00', '19:45'), entry('19:50', '20:35')] },
|
||
},
|
||
});
|
||
record(
|
||
'插件上报两节课（其中一节随后会被删除）',
|
||
ghostReport.payload?.data?.scheduleApplied === true,
|
||
`status=${ghostReport.status}`,
|
||
);
|
||
|
||
const beforePrune = await listSaturday();
|
||
record('上报后两节都在库里', beforePrune.length === 2, `周六 19 点=${beforePrune.length} 节`);
|
||
|
||
// 第二次上报：只报第二节 → 第一节应当被清理。
|
||
// 原先 merge 只 upsert、从不删除，老师删掉的课会永远留在服务端（幽灵课），
|
||
// ClassHelper 班级端与 Web 端会一直显示一节实际上已经不上的课。
|
||
const pruneReport = await api('/integrations/classisland/report', {
|
||
method: 'POST',
|
||
deviceToken,
|
||
body: {
|
||
deviceKey: 'smoke-machine-01',
|
||
schedule: { mode: 'merge', entries: [entry('19:50', '20:35')] },
|
||
},
|
||
});
|
||
const afterPrune = await listSaturday();
|
||
record(
|
||
'插件侧删除的课被同步清理（不再留幽灵课）',
|
||
pruneReport.payload?.data?.scheduleApplied === true &&
|
||
afterPrune.length === 1 &&
|
||
afterPrune[0]?.startTime === '19:50',
|
||
`周六 19 点=${afterPrune.map((item) => item.startTime).join(',') || '空'}`,
|
||
);
|
||
|
||
// 只清理"插件同步出来的行"：老师手排的课必须活着
|
||
const scheduleList = await api(`/schedules?classId=${target.id}`, { token: teacherToken });
|
||
const manualAlive = (scheduleList.payload?.data ?? []).some((item) => item.id === manualScheduleId);
|
||
record('Web 端手排的课不被插件同步删除', manualAlive, `手排行 id=${manualScheduleId ?? '-'}`);
|
||
|
||
// 机器码回填：设备列表里不再是 pending-…
|
||
const deviceList = await api(`/integrations/devices?classId=${target.id}`, { token: teacherToken });
|
||
const backfilledKey =
|
||
(deviceList.payload?.data ?? []).find((item) => item.id === deviceId)?.deviceKey ?? '';
|
||
record(
|
||
'插件上报的机器码已回填到设备记录',
|
||
backfilledKey === 'smoke-machine-01',
|
||
`deviceKey=${backfilledKey}`,
|
||
);
|
||
|
||
// 清理：把手排的课与本次上报写进去的课都删掉，避免污染演示数据
|
||
if (manualScheduleId) {
|
||
await api(`/schedules/${manualScheduleId}`, { method: 'DELETE', token: teacherToken });
|
||
}
|
||
for (const row of await listSaturday()) {
|
||
await api(`/schedules/${row.id}`, { method: 'DELETE', token: teacherToken });
|
||
}
|
||
record('清理：本次验证写入的课表与手排课已删除', (await listSaturday()).length === 0, '周六 19 点已清空');
|
||
|
||
// ---------------------------------------------------------------- 6. 停用设备
|
||
await api(`/integrations/devices/${deviceId}`, {
|
||
method: 'PATCH',
|
||
token: teacherToken,
|
||
body: { enabled: false },
|
||
});
|
||
const blocked = await api('/integrations/classisland/report', {
|
||
method: 'POST',
|
||
deviceToken,
|
||
body: { state: { inClass: false, clientTime: new Date().toISOString() } },
|
||
});
|
||
record('停用设备后插件上报被拒（403）', blocked.status === 403, `status=${blocked.status}`);
|
||
|
||
// ---------------------------------------------------------------- 7. 权限隔离
|
||
// 班级码只有管理员/班主任可见，班级密码也是默认值，因此这里按管理员信息补齐
|
||
let classCode = target.code ?? null;
|
||
if (!classCode && adminToken) {
|
||
const all = await api('/classes', { token: adminToken });
|
||
classCode = (all.payload?.data ?? []).find((item) => item.id === target.id)?.code ?? null;
|
||
}
|
||
const studentLogin = await api('/auth/class-login', {
|
||
method: 'POST',
|
||
body: { code: classCode ?? '', password: '123456' },
|
||
});
|
||
const studentToken = studentLogin.payload?.data?.token;
|
||
if (studentToken) {
|
||
const forbidden = await api('/integrations/devices', { token: studentToken });
|
||
record('学生无法查看联动设备列表（403）', forbidden.status === 403, `status=${forbidden.status}`);
|
||
} else {
|
||
record('班级账号登录（跳过学生隔离用例）', false, `status=${studentLogin.status}`);
|
||
}
|
||
|
||
// ---------------------------------------------------------------- 清理
|
||
const removed = await api(`/integrations/devices/${deviceId}`, { method: 'DELETE', token: teacherToken });
|
||
record('删除验证设备（清理）', removed.status === 200, `status=${removed.status}`);
|
||
|
||
const failed = results.filter((item) => !item.ok);
|
||
console.log(`\n=== 结果：${results.length - failed.length}/${results.length} 通过 ===`);
|
||
if (failed.length > 0) {
|
||
console.log('失败用例：');
|
||
for (const item of failed) console.log(` - ${item.name} (${item.detail})`);
|
||
process.exit(1);
|
||
}
|
||
console.log('ClassIsland 联动链路全部通过。\n');
|
||
}
|
||
|
||
main().catch((error) => {
|
||
console.error('验证脚本异常：', error);
|
||
process.exit(1);
|
||
});
|