feat(permissions,clients,ai,system,server,web,client,shared)!: 权限组 + 客户端设备远控与自动更新 + 大模型助手 + 系统诊断(1.3.0)

功能级准入改为「权限键」,`requireRole` 退成默认模板。

权限组
- 权限目录(39 键:键 / 中文名 / 分类 / 默认角色)收口到 shared,路由挂 requirePermission / requireAnyPermission
- 有效权限每请求实时算,改完分组立刻生效:ADMIN 全集且 permission:manage、system:manage 不可剥夺;
  CLASS_DEVICE 空集(不受分组影响);有分组 = 并集(因此也能用来**收回**权限);无分组 = 角色默认模板
- 新增「权限组」页:组增删改、成员分配、生效权限预览
- 班级维度的科目规则(assertCanManageSubjectContent)故意不可被权限组覆盖

客户端设备(ClassHelper 桌面端)
- 设备身份是 deviceKey(首次启动生成的 UUID,saveConfig 拒绝改写、退出登录也保留)
- 心跳走「DB 记状态 + 客户端定时拉」,不引入新的长连接:30 秒一次,在线窗口 90 秒
- 远控命令 shutdown / restart / logoff / lock:服务端有效期 10 分钟,客户端弹默认选中「取消」的对话框、
  60 秒未确认按取消处理,执行后必须回执(重复回执幂等),同一台机器同一条命令只弹一次
- 新增「客户端设备」页:版本一览、一键推送更新、下发远控

客户端安装包由服务端下载并缓存(教室机常常没有外网,浏览器也受 CSP 限制)
- POST /api/update/client/fetch 由服务端下载到 data/client-releases/<版本>/ 并登记 sha256 + size
- 自动安装三条护栏:没有 sha256 就拒收、必须等到非上课且主窗口隐藏满 5 分钟、冒烟模式永不安装

大模型助手:只解析、不落库
- POST /api/ai/interpret 返回**待确认**的结构化动作(建作业 / 发通知 / 叫人),
  真正落库仍调既有端点 —— 权限断言、上课时段紧急通知保护、ClassIsland 推送全部自动复用
- 模型给的 params 用与手动入口**同一份** zod 再校验(模型输出不可信)
- API Key 走 AES-256-GCM(密钥由 JWT_SECRET 经 scrypt 派生)加密存 AppSetting,只进不出
- provider=mock 是离线确定性解析,自动化验收一律用它;每次解析写一条 AiAudit(不含密钥)

系统与运维
- 开发者模式(服务端内存缓存开关,热路径不查库;开启后 500 才附 error.stack)、运行诊断(绝不回传密钥)
- 开机自启动运行期可改:Windows 改 HKCU\...\Run、Linux systemctl enable/disable,
  **非安装形态一律返回 supported:false**,不往开发机的注册表里写自启项
- 服务端侧栏折叠只用 CSS 收拢(不重建 DOM),关怀模式只放大字号与控件、不动任何几何令牌

客户端
- 崩溃自愈:渲染进程挂掉 / 超 10 秒无响应先静默重建主窗口(10 分钟最多 3 次),
  未捕获异常只在「没在上课、没人看着」时才重启进程;冒烟模式绝不重启(会杀掉验证实例)
- 上线补弹离线期间收到的消息只做一次:起点只在「可达 → 不可达」的边界写,恢复时取最近 5 条按时间升序推

发布内容批量
- POST /notifications/bulk、POST /homeworks/bulk:**单班失败不影响整批**,逐班返回结果
- 作业的科目名跨班**按名匹配**已有课程,找不到就整班记失败,绝不自动建课
  (自动建课会把创建者写成任课老师,等于越权改任教关系)
- 通知与作业同口径按「所属日期」归档,新增 /notifications/days 与 /notifications/creators

BREAKING CHANGE: 能不能做某件事不再看角色名,而是看权限键(GET /api/permissions/me)。
未分组的账号按角色默认模板生效,行为与 1.2.0 一致;分组之后生效集合只由组的并集决定。
服务端首次启动会自动应用 1 个数据库迁移(权限组 3 表 / AppSetting / 客户端设备·命令·安装包 /
AiAudit / Notification.assignDate / User.careMode,历史通知按本地日期回填),升级前请先备份。
This commit is contained in:
LoveChengke committed 2026-10-11 11:49:32 +08:00
1 parent e51879667a
commit 817af02357
131 files changed
+12995 -538

No files matched your search

@@ -0,0 +1,452 @@
<script setup lang="ts">
import { computed, onMounted, reactive, ref } from 'vue';
import { ElMessage, ElMessageBox } from 'element-plus';
import {
formatDate,
type AiAuditDto,
type AiSettingsDto,
type SystemDiagnosticsDto,
type UpdateAiSettingsRequest,
} from '@classhelper/shared';
import { aiApi, systemApi } from '@/api';
import { useAuthStore } from '@/stores/auth';
import { useResponsive } from '@/composables/useResponsive';
/**
* 大模型设置(`ai:manage`)。
*
* 三个 Tab 的理由:
* 1. 「模型配置」—— 开关与接入参数。**密钥单向**:`GET /ai/settings` 永不回传密钥,
* 只回 `hasApiKey` + `keyHint`(尾号),所以输入框永远是空的,"留空 = 不修改"是刻意的语义
* (见 `api/index.ts` 的 `aiApi.updateSettings` 与 `modules/ai/ai.service.ts` 的 put 分支)。
* 2. 「使用记录」—— 解析审计(谁、什么原话、判断成什么动作)。
* 本页只读,不做"发布回执":审计行是解析那一刻写的(`status: 'pending'`),
* 真正发布走的是既有发布端点,那不是助手链路的事。
* 3. 「系统」(仅 `system:manage`)—— 开发者模式 + 只读诊断。
* 放在这里而不是单独开一个路由,是因为它权限更高、平时不需要看,
* Tabs 天然按权限隐藏(没有 system:manage 的人连标签都看不到),比多一个菜单项更省事。
*/
const auth = useAuthStore();
const { isMobile } = useResponsive();
/** 开发者模式/诊断属于 `system:manage`,与页面本身的 `ai:manage` 不是一回事 */
const canManageSystem = computed(() => auth.can('system:manage'));
type TabName = 'model' | 'audit' | 'system';
const activeTab = ref<TabName>('model');
/* ------------------------------------------------------------ 模型配置 */
type Provider = AiSettingsDto['provider'];
const loading = ref(true);
const saving = ref(false);
const clearingKey = ref(false);
const form = reactive({
enabled: false,
provider: 'openai' as Provider,
baseUrl: '',
model: '',
systemPromptExtra: '',
});
/** 已保存的密钥信息(只用于显示,永不回填到输入框) */
const hasApiKey = ref(false);
const keyHint = ref('');
/** 本次要写入的新密钥;留空 = 保持原密钥不变 */
const apiKeyInput = ref('');
const providerHint = computed(() =>
form.provider === 'mock'
? '离线示例解析:不联网,只按关键词猜测,供演示与验收。'
: 'OpenAI 兼容接口:请求 {服务地址}/chat/completions,适用于 OpenAI、通义、DeepSeek 等兼容服务。',
);
function applySettings(settings: AiSettingsDto): void {
form.enabled = settings.enabled;
form.provider = settings.provider;
form.baseUrl = settings.baseUrl;
form.model = settings.model;
form.systemPromptExtra = settings.systemPromptExtra;
hasApiKey.value = settings.hasApiKey;
keyHint.value = settings.keyHint;
apiKeyInput.value = '';
}
async function loadSettings(): Promise<void> {
loading.value = true;
try {
applySettings(await aiApi.settings());
} catch {
// 响应拦截器已经弹过服务端的中文提示,这里只保证页面不是一片空白
} finally {
loading.value = false;
}
}
async function save(): Promise<void> {
saving.value = true;
try {
const payload: UpdateAiSettingsRequest = {
enabled: form.enabled,
provider: form.provider,
baseUrl: form.baseUrl.trim(),
model: form.model.trim(),
systemPromptExtra: form.systemPromptExtra,
};
// 只有真的填了新密钥才带上 apiKey:不带 = 保持原值,null = 清除
const typedKey = apiKeyInput.value.trim();
if (typedKey) payload.apiKey = typedKey;
applySettings(await aiApi.updateSettings(payload));
ElMessage.success('设置已保存');
} catch {
// 同上:错误提示由拦截器统一给出
} finally {
saving.value = false;
}
}
async function clearApiKey(): Promise<void> {
try {
await ElMessageBox.confirm('清除后助手无法调用真实大模型;确认清除已保存的密钥吗?', '清除密钥', {
type: 'warning',
confirmButtonText: '清除',
cancelButtonText: '取消',
});
} catch {
return;
}
clearingKey.value = true;
try {
// apiKey: null 是"清除"的约定(空串在服务端同样按清除处理)
applySettings(await aiApi.updateSettings({ apiKey: null }));
ElMessage.success('密钥已清除');
} catch {
// 拦截器已提示
} finally {
clearingKey.value = false;
}
}
/* ------------------------------------------------------------ 使用记录 */
const audit = ref<AiAuditDto[]>([]);
const auditLoading = ref(false);
const INTENT_LABELS: Record<string, string> = {
create_homework: '布置作业',
create_notification: '发布通知',
call_student: '叫同学来',
unknown: '没听懂',
};
const STATUS_LABELS: Record<string, string> = {
pending: '已解析',
confirmed: '已发布',
cancelled: '已放弃',
failed: '发布失败',
};
function intentLabel(intent: string): string {
return INTENT_LABELS[intent] ?? intent;
}
function statusLabel(status: string): string {
return STATUS_LABELS[status] ?? status;
}
async function loadAudit(): Promise<void> {
auditLoading.value = true;
try {
audit.value = await aiApi.audit(50);
} catch {
// 拦截器已提示
} finally {
auditLoading.value = false;
}
}
/* ------------------------------------------------------------ 系统/开发者 */
const developerMode = ref(false);
const systemSaving = ref(false);
const diagnostics = ref<SystemDiagnosticsDto | null>(null);
const diagnosticsLoading = ref(false);
async function loadSystemSettings(): Promise<void> {
try {
developerMode.value = (await systemApi.settings()).developerMode;
} catch {
// 拦截器已提示
}
}
async function handleDeveloperModeChange(value: boolean | string | number): Promise<void> {
const next = value === true;
const previous = developerMode.value;
developerMode.value = next;
systemSaving.value = true;
try {
await systemApi.updateSettings({ developerMode: next });
ElMessage.success(next ? '开发者模式已开启' : '开发者模式已关闭');
} catch {
developerMode.value = previous;
} finally {
systemSaving.value = false;
}
}
async function loadDiagnostics(): Promise<void> {
diagnosticsLoading.value = true;
try {
diagnostics.value = await systemApi.diagnostics();
} catch {
// 拦截器已提示
} finally {
diagnosticsLoading.value = false;
}
}
/** 运行时长(秒 → 「3 天 4 小时 5 分」),纯展示,不做精度承诺 */
function formatUptime(seconds: number | undefined): string {
if (seconds === undefined) return '—';
const days = Math.floor(seconds / 86400);
const hours = Math.floor((seconds % 86400) / 3600);
const minutes = Math.floor((seconds % 3600) / 60);
const parts: string[] = [];
if (days > 0) parts.push(`${days} 天`);
if (hours > 0) parts.push(`${hours} 小时`);
parts.push(`${minutes} 分`);
return parts.join(' ');
}
/* ------------------------------------------------------------ 生命周期 */
onMounted(async () => {
await loadSettings();
await loadAudit();
if (canManageSystem.value) {
await loadSystemSettings();
await loadDiagnostics();
}
});
</script>
<template>
<div class="page">
<div class="page-header">
<div>
<h2 class="page-title">大模型设置</h2>
<p class="page-subtitle">配置「AI 助手」用哪种解析方式;助手只解析、不写库,发布始终由老师确认</p>
</div>
</div>
<el-tabs v-model="activeTab" class="settings-tabs">
<el-tab-pane label="模型配置" name="model">
<el-card v-loading="loading" shadow="never">
<el-form :model="form" :label-width="isMobile ? undefined : '132px'" :label-position="isMobile ? 'top' : 'right'">
<el-form-item label="启用助手">
<el-switch v-model="form.enabled" data-test="ai-enabled" />
<span class="field-hint">关闭后教师在「AI 助手」页会看到"还没启用"的空态</span>
</el-form-item>
<el-form-item label="解析方式">
<el-radio-group v-model="form.provider">
<el-radio value="openai">OpenAI 兼容接口</el-radio>
<el-radio value="mock">离线示例解析</el-radio>
</el-radio-group>
<p class="field-hint">{{ providerHint }}</p>
</el-form-item>
<template v-if="form.provider === 'openai'">
<el-form-item label="服务地址">
<el-input v-model="form.baseUrl" placeholder="https://api.openai.com/v1" class="field-input" />
</el-form-item>
<el-form-item label="模型名">
<el-input v-model="form.model" placeholder="gpt-4o-mini(留空即用默认)" class="field-input" />
</el-form-item>
<el-form-item label="API 密钥">
<div class="key-row">
<el-input
v-model="apiKeyInput"
type="password"
show-password
class="field-input"
:placeholder="hasApiKey ? `已配置(尾号 ${keyHint}),留空表示不修改` : '粘贴密钥,保存后不再显示'"
/>
<el-button v-if="hasApiKey" :loading="clearingKey" @click="clearApiKey">清除密钥</el-button>
</div>
<p class="field-hint">密钥只保存在服务端;接口永不回传明文,所以这里不会回填。</p>
</el-form-item>
</template>
<el-form-item label="补充提示词">
<el-input
v-model="form.systemPromptExtra"
type="textarea"
:rows="3"
class="field-input"
placeholder="例如:本校的班级叫「高一二班」这样的名字;把「卷子」理解为作业"
/>
<p class="field-hint">追加在系统提示词末尾,用来补充本校的称呼习惯。</p>
</el-form-item>
<el-form-item>
<el-button type="primary" :loading="saving" data-test="ai-save" @click="save">保存</el-button>
<el-button :disabled="saving" @click="loadSettings">重新载入</el-button>
</el-form-item>
</el-form>
</el-card>
</el-tab-pane>
<el-tab-pane label="使用记录" name="audit">
<el-card shadow="never">
<div class="table-toolbar">
<span class="field-hint">最近 50 条解析记录(只记录解析这一步,发布结果不在这张表里)</span>
<el-button :loading="auditLoading" @click="loadAudit">刷新</el-button>
</div>
<el-table v-loading="auditLoading" :data="audit" class="table-card" empty-text="还没有解析记录">
<el-table-column label="时间" width="150">
<template #default="{ row }">
<span class="cell-muted">{{ formatDate((row as AiAuditDto).createdAt, true) }}</span>
</template>
</el-table-column>
<el-table-column label="操作人" width="120">
<template #default="{ row }">{{ (row as AiAuditDto).userName || '—' }}</template>
</el-table-column>
<el-table-column label="原话" min-width="220" show-overflow-tooltip>
<template #default="{ row }">{{ (row as AiAuditDto).prompt }}</template>
</el-table-column>
<el-table-column label="动作" width="110">
<template #default="{ row }">
<el-tag size="small" effect="plain">{{ intentLabel((row as AiAuditDto).intent) }}</el-tag>
</template>
</el-table-column>
<el-table-column label="结果" min-width="220" show-overflow-tooltip>
<template #default="{ row }">
<el-tag size="small" type="info" effect="plain">
{{ statusLabel((row as AiAuditDto).status) }}
</el-tag>
<span class="cell-text">{{ (row as AiAuditDto).message }}</span>
</template>
</el-table-column>
</el-table>
</el-card>
</el-tab-pane>
<el-tab-pane v-if="canManageSystem" label="系统" name="system">
<el-card shadow="never" class="system-card">
<div class="switch-row">
<div>
<p class="switch-title">开发者模式</p>
<p class="field-hint">
打开后只把开关记在服务端配置里(用于排查问题时确认环境),不改变老师与学生的日常使用。
</p>
</div>
<el-switch
:model-value="developerMode"
:loading="systemSaving"
@update:model-value="handleDeveloperModeChange"
/>
</div>
</el-card>
<el-card v-loading="diagnosticsLoading" shadow="never" class="system-card">
<template #header>
<div class="table-toolbar">
<span>服务端诊断</span>
<el-button :loading="diagnosticsLoading" @click="loadDiagnostics">刷新</el-button>
</div>
</template>
<el-descriptions :column="isMobile ? 1 : 2" size="small" border>
<el-descriptions-item label="版本">{{ diagnostics?.version ?? '—' }}</el-descriptions-item>
<el-descriptions-item label="Node">{{ diagnostics?.nodeVersion ?? '—' }}</el-descriptions-item>
<el-descriptions-item label="平台">{{ diagnostics?.platform ?? '—' }}</el-descriptions-item>
<el-descriptions-item label="已运行">{{ formatUptime(diagnostics?.uptimeSeconds) }}</el-descriptions-item>
<el-descriptions-item label="数据库">{{ diagnostics?.databaseProvider ?? '—' }}</el-descriptions-item>
<el-descriptions-item label="在线客户端">
{{ diagnostics?.onlineClientCount ?? '—' }}
</el-descriptions-item>
<el-descriptions-item label="已发布客户端版本">
{{ diagnostics?.clientReleaseCount ?? '—' }}
</el-descriptions-item>
<el-descriptions-item label="已加载模块">{{ diagnostics?.moduleCount ?? '—' }}</el-descriptions-item>
<el-descriptions-item label="服务端目录" :span="isMobile ? 1 : 2">
<span class="cell-path">{{ diagnostics?.serverRoot ?? '—' }}</span>
</el-descriptions-item>
<el-descriptions-item label="数据目录" :span="isMobile ? 1 : 2">
<span class="cell-path">{{ diagnostics?.dataDir ?? '—' }}</span>
</el-descriptions-item>
</el-descriptions>
</el-card>
</el-tab-pane>
</el-tabs>
</div>
</template>
<style scoped>
.settings-tabs {
margin-top: -4px;
}
.field-input {
max-width: 420px;
}
.field-hint {
margin: 4px 0 0;
color: var(--ch-text-muted);
font-size: var(--el-font-size-extra-small);
line-height: 1.6;
}
.key-row {
display: flex;
align-items: center;
gap: 8px;
width: 100%;
}
.table-toolbar {
display: flex;
align-items: center;
justify-content: space-between;
gap: 12px;
margin-bottom: 12px;
}
.cell-muted {
color: var(--ch-text-secondary);
}
.cell-text {
margin-left: 8px;
color: var(--ch-text-secondary);
}
.cell-path {
word-break: break-all;
font-family: var(--el-font-family-mono, monospace);
font-size: var(--el-font-size-extra-small);
}
.system-card + .system-card {
margin-top: 16px;
}
.switch-row {
display: flex;
align-items: flex-start;
justify-content: space-between;
gap: 16px;
}
.switch-title {
margin: 0;
font-weight: 600;
}
</style>
@@ -0,0 +1,644 @@
<script setup lang="ts">
import { computed, nextTick, onMounted, reactive, ref } from 'vue';
import { useRouter } from 'vue-router';
import axios from 'axios';
import { ElMessage, ElMessageBox, type FormInstance, type FormRules } from 'element-plus';
import {
NOTIFICATION_PRIORITIES,
PRIORITY_LABELS,
dayKeyLocal,
type AiInterpretResult,
type ApiErrorResponse,
type ClassDto,
type CourseDto,
type NotificationPriority,
type StudentDto,
} from '@classhelper/shared';
import { aiApi, callApi, classApi, courseApi, homeworkApi, notificationApi } from '@/api';
import { useAuthStore } from '@/stores/auth';
import { useResponsive } from '@/composables/useResponsive';
/**
* AI 助手:**一句话 → 待确认的草稿 → 老师确认后才落库**。
*
* 三条边界(与服务端 `modules/ai/ai.service.ts` 的设计一一对应):
* 1. 助手**只解析、不写业务表**:`POST /ai/interpret` 返回的是结构化参数与中文预览,
* 真正发布走的仍是既有端点(`POST /homeworks` / `/notifications` / `/calls`)——
* 于是科目权限断言、上课时段紧急通知保护、ClassIsland 推送全部自动复用,不会另开一条旁路。
* 2. **参数可改**:模型的输出不可信(服务端自己也会用同一份 zod 再校验一遍),
* 所以解析结果一律填进表单让老师过目、修改,而不是直接提交。
* 3. **教师不读配置**:`GET /ai/settings` 要 `ai:manage`,教师读会 403 且响应拦截器会弹一条错误提示。
* 所以只有管理者才去读配置判断"是否启用",教师侧走"探测式"——
* 直接解析,服务端回 `AI_NOT_CONFIGURED` 时再切到空态(见 interpret())。
*/
const auth = useAuthStore();
const router = useRouter();
const { isMobile } = useResponsive();
const canManage = computed(() => auth.can('ai:manage'));
/* -------------------------------------------------------------- 可用性 */
/** checking = 管理者正在读配置;ready = 可以用;disabled = 还没启用(显示空态) */
type AssistantState = 'checking' | 'ready' | 'disabled';
const state = ref<AssistantState>('checking');
const disabledReason = ref('助手还没启用,请管理员在「大模型设置」里配置');
/* -------------------------------------------------------------- 输入 */
const text = ref('');
const interpreting = ref(false);
const result = ref<AiInterpretResult | null>(null);
/** 发布失败的中文原因(常驻在结果卡片里,不只靠一条会消失的 toast) */
const publishError = ref('');
const publishing = ref(false);
/* -------------------------------------------------------------- 表单 */
const classes = ref<ClassDto[]>([]);
const courseOptions = ref<CourseDto[]>([]);
const students = ref<StudentDto[]>([]);
/** 叫人时按姓名匹配的结果说明(没匹配到要让老师自己选,不能默默留空) */
const studentHint = ref('');
const formRef = ref<FormInstance>();
const form = reactive({
classId: '',
courseId: '',
title: '',
content: '',
assignDate: dayKeyLocal(new Date()),
priority: 'NORMAL' as NotificationPriority,
studentId: '',
message: '',
});
const rules = computed<FormRules>(() => {
const action = result.value?.action;
const base: FormRules = {
classId: [{ required: true, message: '请选择班级', trigger: 'change' }],
};
if (action === 'create_homework' || action === 'create_notification') {
base.title = [{ required: true, message: '请填写标题', trigger: 'blur' }];
base.content = [{ required: true, message: '请填写内容', trigger: 'blur' }];
}
if (action === 'call_student') {
base.studentId = [{ required: true, message: '请选择要叫的同学', trigger: 'change' }];
}
return base;
});
const actionLabel = computed(() => {
switch (result.value?.action) {
case 'create_homework':
return '布置作业';
case 'create_notification':
return '发布通知';
case 'call_student':
return '叫同学来';
default:
return '没听懂';
}
});
const confidencePercent = computed(() => `${Math.round((result.value?.confidence ?? 0) * 100)}%`);
const confidenceType = computed(() => ((result.value?.confidence ?? 0) < 0.5 ? 'warning' : 'success'));
/* -------------------------------------------------------------- 工具 */
function str(value: unknown): string {
return typeof value === 'string' ? value : '';
}
function isPriority(value: unknown): value is NotificationPriority {
return typeof value === 'string' && (NOTIFICATION_PRIORITIES as readonly string[]).includes(value);
}
/**
* 统一的错误读取。
*
* `api/http.ts` 的响应拦截器**已经弹过一次**服务端的中文提示(这就是不在这里重复 toast 的原因),
* 这里只是把状态码与业务码取出来,好做分支判断(403 科目越权 / 409 上课时段紧急通知)。
*/
function readServerError(error: unknown): { status: number; code: string; message: string } {
if (axios.isAxiosError<ApiErrorResponse>(error)) {
return {
status: error.response?.status ?? 0,
code: error.response?.data?.code ?? '',
message: error.response?.data?.message ?? error.message,
};
}
return { status: 0, code: '', message: error instanceof Error ? error.message : '请求失败' };
}
/* -------------------------------------------------------------- 加载 */
async function loadClasses(): Promise<void> {
try {
classes.value = await classApi.list();
} catch {
// 拦截器已提示;拿不到班级时后面的表单会缺选项,但不至于整页报错
classes.value = [];
}
}
async function refreshCourses(): Promise<void> {
courseOptions.value = form.classId ? await courseApi.list(form.classId).catch(() => []) : [];
}
async function refreshStudents(): Promise<void> {
students.value = form.classId ? await classApi.students(form.classId).catch(() => []) : [];
}
/** 换班级:科目与名单都得跟着换,否则会把 A 班的科目发到 B 班 */
async function onClassChange(): Promise<void> {
form.courseId = '';
form.studentId = '';
studentHint.value = '';
await refreshCourses();
if (result.value?.action === 'call_student') await refreshStudents();
}
/**
* 叫人的学生匹配:助手的 `call_student` 通常只给 `studentName`(预览也按姓名查过),
* 而 `POST /calls` 要的是 `studentId`。同名或没匹配到都**不猜**,交给老师在下拉里选。
*/
async function resolveStudent(params: Record<string, unknown>): Promise<void> {
await refreshStudents();
const byId = str(params.studentId);
if (byId && students.value.some((item) => item.id === byId)) {
form.studentId = byId;
studentHint.value = '';
return;
}
const name = str(params.studentName);
if (!name) {
studentHint.value = '助手没识别出学生姓名,请手动选择。';
return;
}
const matched = students.value.filter((item) => item.name === name);
if (matched.length === 1) {
form.studentId = matched[0]?.id ?? '';
studentHint.value = '';
return;
}
studentHint.value =
matched.length > 1
? `本班有 ${matched.length} 位「${name}」,请手动选择是哪一位。`
: `本班没找到「${name}」,请手动选择。`;
}
/* -------------------------------------------------------------- 解析 */
async function interpret(): Promise<void> {
const value = text.value.trim();
if (!value) {
ElMessage.warning('先说说要做什么,例如「给高一二班布置作业,让他们把卷子写完」');
return;
}
interpreting.value = true;
publishError.value = '';
try {
const data = await aiApi.interpret({ text: value, classId: form.classId || undefined });
result.value = data;
await fillForm(data);
} catch (error) {
const info = readServerError(error);
// 未启用 / 没配服务地址与密钥:服务端用同一个业务码区分,这里统一切到空态
if (info.code === 'AI_NOT_CONFIGURED') {
state.value = 'disabled';
disabledReason.value = info.message;
result.value = null;
}
} finally {
interpreting.value = false;
}
}
/** 把解析出的参数填进表单(解析结果只是**草稿**,老师可以逐项改) */
async function fillForm(data: AiInterpretResult): Promise<void> {
const params = data.params ?? {};
form.classId = str(params.classId) || form.classId || classes.value[0]?.id || '';
form.courseId = str(params.courseId);
form.title = str(params.title);
form.content = str(params.content);
form.assignDate = str(params.assignDate) || dayKeyLocal(new Date());
form.priority = isPriority(params.priority) ? params.priority : 'NORMAL';
form.studentId = '';
form.message = str(params.message);
studentHint.value = '';
await refreshCourses();
if (data.action === 'call_student') await resolveStudent(params);
// 表单是 v-if 出来的:等它挂载完再清掉上一次残留的校验红字
await nextTick();
formRef.value?.clearValidate();
}
/* -------------------------------------------------------------- 发布 */
async function confirmPublish(): Promise<void> {
const current = result.value;
if (!current || current.action === 'unknown') return;
const valid = await formRef.value?.validate().catch(() => false);
if (!valid) return;
publishing.value = true;
publishError.value = '';
try {
await publishOnce(current.action, false);
finishSuccess(current.action);
} catch (error) {
await handlePublishError(error, current.action);
} finally {
publishing.value = false;
}
}
/** 真正落库:复用既有的发布端点(权限断言 / 上课保护 / ClassIsland 推送都在服务端) */
async function publishOnce(action: AiInterpretResult['action'], confirmDuringClass: boolean): Promise<void> {
if (action === 'create_homework') {
await homeworkApi.create({
classId: form.classId,
courseId: form.courseId || null,
title: form.title.trim(),
content: form.content,
assignDate: form.assignDate || null,
});
return;
}
if (action === 'create_notification') {
await notificationApi.create({
classId: form.classId,
title: form.title.trim(),
content: form.content,
priority: form.priority,
...(confirmDuringClass ? { confirmDuringClass: true } : {}),
});
return;
}
await callApi.create({
classId: form.classId,
studentId: form.studentId,
message: form.message.trim() || undefined,
});
}
function finishSuccess(action: AiInterpretResult['action']): void {
ElMessage.success(
action === 'create_homework'
? '作业已发布,已推送给该班学生'
: action === 'create_notification'
? '通知已发布,已推送给该班学生'
: '已通知该同学到老师这里',
);
// 发布成功后清空结果:同一句话不会被误发第二遍
result.value = null;
text.value = '';
publishError.value = '';
studentHint.value = '';
}
/**
* 失败分支。
*
* 服务端的 403(如「不是你任教的科目」)与其它 4xx 的中文提示**已经由响应拦截器弹过**,
* 这里只做两件拦截器做不了的事:
* 1. 把原因常驻在结果卡片里(toast 会消失,而老师需要边看参数边改);
* 2. 上课时段的紧急通知(409 `URGENT_DURING_CLASS`)再问一次 —— 服务端要求二次确认才放行。
*/
async function handlePublishError(error: unknown, action: AiInterpretResult['action']): Promise<void> {
const info = readServerError(error);
if (info.status === 409 && info.code === 'URGENT_DURING_CLASS' && action === 'create_notification') {
try {
await ElMessageBox.confirm(
'正在上课,紧急通知需二次确认。确认立即把这条通知发到班级吗?',
'上课时段发布紧急通知',
{ type: 'warning', confirmButtonText: '继续发布', cancelButtonText: '取消' },
);
} catch {
publishError.value = '已取消:正在上课,紧急通知需要二次确认';
return;
}
try {
await publishOnce(action, true);
finishSuccess(action);
} catch (retryError) {
publishError.value = readServerError(retryError).message;
}
return;
}
publishError.value = info.message;
}
/* -------------------------------------------------------------- 生命周期 */
onMounted(async () => {
await loadClasses();
if (canManage.value) {
// 管理者:读一次配置就能给出准确空态(教师不能读,会 403)
try {
const settings = await aiApi.settings();
if (!settings.enabled) {
state.value = 'disabled';
disabledReason.value = '助手还没启用,请管理员在「大模型设置」里配置';
} else if (settings.provider === 'openai' && (!settings.hasApiKey || !settings.baseUrl)) {
state.value = 'disabled';
disabledReason.value = '还没配置大模型服务地址或密钥,请管理员在「大模型设置」里填写';
} else {
state.value = 'ready';
}
} catch {
// 读配置失败不该把老师挡在门外:按"可以用"处理,真正的判据交给解析时的报错
state.value = 'ready';
}
return;
}
// 教师(或权限还没拉回来时):探测式 —— 直接允许输入,解析报 AI_NOT_CONFIGURED 再切空态
state.value = 'ready';
});
function goSettings(): void {
void router.push('/ai-settings');
}
</script>
<template>
<div class="page">
<div class="page-header">
<div>
<h2 class="page-title">AI 助手</h2>
<p class="page-subtitle">
用一句话说清要做什么,助手解析成可修改的草稿;<b>确认发布后</b>才会真正发到班级
</p>
</div>
</div>
<!-- 读配置中:先占位,避免"先看到输入框、再被空态替换"的闪动 -->
<el-card v-if="state === 'checking'" v-loading="true" shadow="never" class="ask-card" />
<!-- 未启用:只说明原因,不给输入框(说了也发不出去) -->
<el-card v-else-if="state === 'disabled'" shadow="never">
<el-empty :description="disabledReason">
<el-button v-if="canManage" type="primary" @click="goSettings">去「大模型设置」</el-button>
</el-empty>
</el-card>
<template v-else>
<el-card shadow="never" class="ask-card">
<div class="ask-row">
<el-input
v-model="text"
type="textarea"
:rows="2"
maxlength="500"
show-word-limit
resize="none"
placeholder="给高一二班布置作业,让他们把卷子写完"
@keydown.enter.exact.prevent="interpret"
/>
<el-button type="primary" :loading="interpreting" data-test="ai-interpret" @click="interpret">
解析
</el-button>
</div>
<p class="ask-hint">回车解析,Shift + 回车换行|可以说「布置作业 / 发通知 / 叫某位同学来办公室」</p>
</el-card>
<el-card v-if="result" shadow="never" class="result-card">
<template #header>
<div class="result-header">
<span class="result-title">{{ actionLabel }}</span>
<el-tag :type="confidenceType" size="small" effect="light">
可信度 {{ confidencePercent }}
</el-tag>
</div>
</template>
<!-- 没听懂:只给一句提示,不摆一堆用不上的表单 -->
<el-empty v-if="result.action === 'unknown'" description="没听懂,请换一种说法" />
<template v-else>
<el-alert
v-if="result.confidence < 0.5"
class="result-alert"
type="warning"
show-icon
:closable="false"
title="助手把握不大,请仔细核对下面的参数再发布"
/>
<el-alert
v-if="publishError"
class="result-alert"
type="error"
show-icon
:closable="false"
:title="publishError"
/>
<p class="result-summary">{{ result.preview.summary }}</p>
<div class="result-meta">
<span>班级:{{ result.preview.className || '(未指定)' }}</span>
<span v-if="result.action === 'create_homework'">
科目:{{ result.preview.courseName || '(不指定科目,仅班主任/管理员可发)' }}
</span>
<span v-if="result.action === 'call_student'">
学生:{{ result.preview.studentName || '(未识别)' }}
</span>
</div>
<ul v-if="result.preview.warnings.length" class="result-warnings">
<li v-for="(warning, index) in result.preview.warnings" :key="index">{{ warning }}</li>
</ul>
<el-form
ref="formRef"
:model="form"
:rules="rules"
:label-width="isMobile ? undefined : '82px'"
:label-position="isMobile ? 'top' : 'right'"
class="result-form"
>
<el-form-item label="班级" prop="classId">
<el-select
v-model="form.classId"
placeholder="选择班级"
class="result-field"
@change="onClassChange"
>
<el-option v-for="item in classes" :key="item.id" :label="item.name" :value="item.id" />
</el-select>
</el-form-item>
<template v-if="result.action === 'create_homework'">
<el-form-item label="科目">
<el-select v-model="form.courseId" clearable placeholder="不指定科目" class="result-field">
<el-option v-for="item in courseOptions" :key="item.id" :label="item.name" :value="item.id" />
</el-select>
</el-form-item>
<el-form-item label="标题" prop="title">
<el-input v-model="form.title" class="result-field" />
</el-form-item>
<el-form-item label="内容" prop="content">
<el-input v-model="form.content" type="textarea" :rows="3" />
</el-form-item>
<el-form-item label="日期">
<el-date-picker
v-model="form.assignDate"
type="date"
value-format="YYYY-MM-DD"
placeholder="作业归属日期"
class="result-field"
/>
</el-form-item>
</template>
<template v-else-if="result.action === 'create_notification'">
<el-form-item label="标题" prop="title">
<el-input v-model="form.title" class="result-field" />
</el-form-item>
<el-form-item label="内容" prop="content">
<el-input v-model="form.content" type="textarea" :rows="3" />
</el-form-item>
<el-form-item label="优先级">
<el-select v-model="form.priority" class="result-field">
<el-option
v-for="item in NOTIFICATION_PRIORITIES"
:key="item"
:label="PRIORITY_LABELS[item]"
:value="item"
/>
</el-select>
</el-form-item>
</template>
<template v-else>
<el-form-item label="学生" prop="studentId">
<el-select
v-model="form.studentId"
filterable
placeholder="选择要叫的同学"
class="result-field"
>
<el-option
v-for="item in students"
:key="item.id"
:label="`${item.name}(${item.studentNo})`"
:value="item.id"
/>
</el-select>
<p v-if="studentHint" class="result-hint">{{ studentHint }}</p>
</el-form-item>
<el-form-item label="留言">
<el-input v-model="form.message" type="textarea" :rows="2" />
</el-form-item>
</template>
</el-form>
<div class="result-actions">
<el-button :disabled="publishing" @click="result = null">放弃</el-button>
<el-button
type="primary"
:loading="publishing"
data-test="ai-confirm"
@click="confirmPublish"
>
确认发布
</el-button>
</div>
</template>
</el-card>
</template>
</div>
</template>
<style scoped>
.ask-card {
margin-bottom: 16px;
}
.ask-row {
display: flex;
align-items: flex-start;
gap: 12px;
}
.ask-row :deep(.el-textarea) {
flex: 1;
}
.ask-row .el-button {
/* 与两行输入框的顶部对齐(按钮不该被拉成和输入框一样高) */
flex: 0 0 auto;
height: var(--el-component-size);
}
.ask-hint {
margin: 8px 0 0;
color: var(--ch-text-muted);
font-size: var(--el-font-size-extra-small);
}
.result-header {
display: flex;
align-items: center;
gap: 8px;
}
.result-title {
font-weight: 600;
}
.result-alert {
margin-bottom: 12px;
}
.result-summary {
margin: 0 0 8px;
font-size: var(--el-font-size-medium);
font-weight: 600;
}
.result-meta {
display: flex;
flex-wrap: wrap;
gap: 4px 16px;
color: var(--ch-text-secondary);
font-size: var(--el-font-size-small);
}
.result-warnings {
margin: 8px 0 0;
padding-left: 18px;
color: var(--el-color-warning);
font-size: var(--el-font-size-small);
}
.result-form {
margin-top: 16px;
}
/* 表单控件不铺满整行:长输入框在宽屏上读起来很累,也容易看错改错 */
.result-field {
max-width: 320px;
}
.result-hint {
margin: 4px 0 0;
color: var(--el-color-warning);
font-size: var(--el-font-size-extra-small);
line-height: 1.5;
}
.result-actions {
display: flex;
justify-content: flex-end;
gap: 8px;
}
</style>
File diff suppressed because it is too large. Load diff
+44 -19
View File
@@ -19,7 +19,7 @@ import {
type StudentDto,
type StudentGradeDetailDto,
} from '@classhelper/shared';
import { classApi, courseApi, gradeApi } from '@/api';
import { classApi, courseApi, courseIdFromExistsError, gradeApi } from '@/api';
import ScoreBarChart from '@/components/ScoreBarChart.vue';
import ScoreLineChart from '@/components/ScoreLineChart.vue';
import TableImportDialog from '@/components/TableImportDialog.vue';
@@ -100,7 +100,6 @@ async function onClassChange(): Promise<void> {
courses.value = await courseApi.list(filter.classId);
students.value = await classApi.students(filter.classId);
await loadGrades();
await loadTeacherSuggestions();
}
/* ------------------------------------------------------------ 图表
@@ -132,9 +131,40 @@ async function resolveCourseId(value: string): Promise<string | null> {
const name = value.slice(SUBJECT_PREFIX.length);
const existing = courses.value.find((item) => item.name === name);
if (existing) return existing.id;
const created = await courseApi.create({ classId: filter.classId, name });
courses.value = [...courses.value, created];
return created.id;
try {
const created = await courseApi.create({ classId: filter.classId, name });
courses.value = [...courses.value, created];
return created.id;
} catch (error) {
// 该班已有同名课程(本地列表过期):复用那一门(服务端 409 COURSE_EXISTS + details.courseId);
// 复用之后成绩的科目写权限照常判定,不会"因为选了新建就变成自己的科目"
const reusedId = courseIdFromExistsError(error);
if (reusedId) return reusedId;
throw error;
}
}
/**
* 录入下拉里可选的课程:**只列自己任教的科目**(管理员不受限)。
*
* 与后端 `assertCanManageSubjectContent` 同源:班主任也不自动拥有本班所有科目的成绩录入权,
* 所以下拉里不给"别人的科目",避免老师选完提交才吃 403。
*/
const ownCourses = computed(() =>
auth.isAdmin ? courses.value : courses.value.filter((item) => item.teacherId === auth.user?.id),
);
/** 能不能在该班新建科目(与课表管理同权限:管理员或本班班主任) */
const canCreateCourse = computed(() => {
if (auth.isAdmin) return true;
return classes.value.find((item) => item.id === filter.classId)?.teacherId === auth.user?.id;
});
/** 录入弹窗的默认科目:优先沿用页面筛选,但筛的是别人的科目时退回"我的科目"第一条 */
function defaultFormCourseId(): string {
const list = ownCourses.value;
if (filter.courseId && list.some((item) => item.id === filter.courseId)) return filter.courseId;
return list[0]?.id ?? '';
}
/* ------------------------------------------------------------ 单条录入 */
@@ -156,7 +186,7 @@ function openSingle(): void {
return;
}
singleForm.studentId = students.value[0]?.id ?? '';
singleForm.courseId = filter.courseId || courses.value[0]?.id || '';
singleForm.courseId = defaultFormCourseId();
singleForm.examName = filter.examName || '期中考试';
singleForm.score = 90;
singleForm.totalScore = 100;
@@ -202,7 +232,7 @@ function openBulk(): void {
ElMessage.warning('该班级暂无学生');
return;
}
bulkForm.courseId = filter.courseId || courses.value[0]?.id || '';
bulkForm.courseId = defaultFormCourseId();
bulkForm.examName = filter.examName || '期中考试';
bulkForm.totalScore = 100;
bulkForm.levelType = 'percent';
@@ -269,7 +299,7 @@ function openLevelBatch(): void {
ElMessage.warning('请先选择班级');
return;
}
levelBatchForm.courseId = filter.courseId || courses.value[0]?.id || '';
levelBatchForm.courseId = defaultFormCourseId();
levelBatchForm.examName = filter.examName || examOptions.value[0] || '';
levelBatchForm.levelType = 'letter';
levelBatchVisible.value = true;
@@ -355,11 +385,6 @@ async function removeGrade(row: GradeDto): Promise<void> {
/* ------------------------------------------------------------ 教师视角建议:按考试分组统计 */
const teacherCourseSuggestions = ref<CourseDto[]>([]);
async function loadTeacherSuggestions(): Promise<void> {
teacherCourseSuggestions.value = courses.value;
}
function onGradeEvent(): void {
void loadGrades();
}
@@ -523,8 +548,8 @@ onUnmounted(() => {
</el-form-item>
<el-form-item label="科目">
<el-select v-model="singleForm.courseId" clearable filterable style="width: 100%">
<el-option v-for="item in courses" :key="item.id" :label="`${item.name}(${item.teacher?.name ?? ''})`" :value="item.id" />
<el-option-group v-if="subjectOptions.length" label="统一科目(自动建课)">
<el-option v-for="item in ownCourses" :key="item.id" :label="`${item.name}(${item.teacher?.name ?? ''})`" :value="item.id" />
<el-option-group v-if="canCreateCourse && subjectOptions.length" label="统一科目(自动建课)">
<el-option
v-for="name in subjectOptions"
:key="name"
@@ -579,12 +604,12 @@ onUnmounted(() => {
<el-form-item label="科目">
<el-select v-model="bulkForm.courseId" clearable filterable style="width: 150px">
<el-option
v-for="item in teacherCourseSuggestions"
v-for="item in ownCourses"
:key="item.id"
:label="item.name"
:value="item.id"
/>
<el-option-group v-if="subjectOptions.length" label="统一科目(自动建课)">
<el-option-group v-if="canCreateCourse && subjectOptions.length" label="统一科目(自动建课)">
<el-option
v-for="name in subjectOptions"
:key="name"
@@ -645,8 +670,8 @@ onUnmounted(() => {
<el-form :model="levelBatchForm" label-width="90px">
<el-form-item label="科目">
<el-select v-model="levelBatchForm.courseId" clearable filterable style="width: 100%">
<el-option v-for="item in courses" :key="item.id" :label="item.name" :value="item.id" />
<el-option-group v-if="subjectOptions.length" label="统一科目(自动建课)">
<el-option v-for="item in ownCourses" :key="item.id" :label="item.name" :value="item.id" />
<el-option-group v-if="canCreateCourse && subjectOptions.length" label="统一科目(自动建课)">
<el-option
v-for="name in subjectOptions"
:key="name"
+189 -5
View File
@@ -13,10 +13,12 @@ import {
type HomeworkDto,
type HomeworkSubmissionsDto,
} from '@classhelper/shared';
import { classApi, courseApi, homeworkApi } from '@/api';
import { classApi, courseApi, courseIdFromExistsError, homeworkApi } from '@/api';
import { useAuthStore } from '@/stores/auth';
import { useRealtimeStore } from '@/stores/realtime';
import { useResponsive } from '@/composables/useResponsive';
const auth = useAuthStore();
const realtime = useRealtimeStore();
const { isMobile } = useResponsive();
@@ -218,6 +220,23 @@ const newSubjectOptions = computed(() => {
return SUBJECT_CATALOG.filter((name) => !existing.has(name));
});
/**
* 发布弹窗里可选的课程:**只列自己任教的科目**(管理员不受限)。
*
* 展示侧的收口与服务端 `assertCanManageSubjectContent` 同源:班主任也不自动拥有
* 本班所有科目的作业权,所以下拉里不给"别人的科目"这个选项 —— 否则老师选了、
* 提交、再吃一个 403,只会以为是系统坏了。留空(不指定科目)仍然允许班主任用。
*/
const ownFormCourses = computed(() =>
auth.isAdmin ? formCourses.value : formCourses.value.filter((item) => item.teacherId === auth.user?.id),
);
/** 该班里能不能新建科目:与课表管理同权限(管理员或本班班主任) */
const canCreateCourse = computed(() => {
if (auth.isAdmin) return true;
return classes.value.find((item) => item.id === form.classId)?.teacherId === auth.user?.id;
});
async function loadFormCourses(): Promise<void> {
if (!form.classId) {
formCourses.value = [];
@@ -292,6 +311,14 @@ async function resolveCourseId(): Promise<string | null> {
formCourses.value = [...formCourses.value, created];
return created.id;
} catch (error) {
// 该班已有同名课程(本地列表过期或别人刚建):复用那一门 ——
// 服务端对同名课程返回 409 COURSE_EXISTS + details.courseId(不许再建第二门同名的,
// 否则创建者会凭空成为该科任课老师,绕过科目维度的写权限)。
const reusedId = courseIdFromExistsError(error);
if (reusedId) {
await loadFormCourses();
return reusedId;
}
// 新建课程需要"管理员或本班班主任"权限(与课表管理一致),科任老师会被 403 拦截
ElMessage.error(
`新建科目「${name}」失败:${
@@ -334,6 +361,89 @@ async function submitForm(): Promise<void> {
await loadHomeworks();
}
/* ------------------------------------------------------------------ 批量布置(多班同发) */
/**
* 批量布置:一次给多个班级布置同一份作业。
*
* 科目按**名称**提交(`subjectName`),不是一个 courseId —— 课程是"班级内"的:
* 同一门「语文」在每个班是不同的 Course 记录,没法共用一个 id。服务端在每个目标班里查同名课程,
* 某个班没有这门课时只让那个班失败(结果里带原因),不会自动建课、也不会拖垮整批。
*/
const bulkVisible = ref(false);
const bulkSending = ref(false);
const bulkForm = reactive({
classIds: [] as string[],
subjectName: '',
title: '',
content: '',
attachmentUrl: '',
assignDate: dayKeyLocal(new Date()),
});
function openBulk(): void {
bulkForm.classIds = filter.classId ? [filter.classId] : [];
bulkForm.subjectName = '';
bulkForm.title = '';
bulkForm.content = '';
bulkForm.attachmentUrl = '';
// 默认跟当前「按天查看」的日期一致
bulkForm.assignDate = filter.date || dayKeyLocal(new Date());
bulkVisible.value = true;
}
function classNameOf(classId: string): string {
return classes.value.find((item) => item.id === classId)?.name ?? classId;
}
async function submitBulk(): Promise<void> {
if (bulkForm.classIds.length === 0) {
ElMessage.warning('请至少选择一个目标班级');
return;
}
if (!bulkForm.title.trim()) {
ElMessage.warning('请输入作业标题');
return;
}
if (!bulkForm.content.trim()) {
ElMessage.warning('请输入作业内容');
return;
}
bulkSending.value = true;
try {
const result = await homeworkApi.bulkCreate({
classIds: bulkForm.classIds,
subjectName: bulkForm.subjectName || null,
title: bulkForm.title.trim(),
content: bulkForm.content,
assignDate: bulkForm.assignDate || null,
attachmentUrl: bulkForm.attachmentUrl.trim() || null,
});
const failures = result.results.filter((item) => !item.ok);
if (failures.length === 0) {
ElMessage.success(`作业已发布到 ${result.succeeded} 个班级,实时推送已发出`);
} else {
const detail = failures
.map((item) => `${classNameOf(item.classId)}(${item.message ?? '失败'})`)
.join(';');
ElMessage({
type: result.succeeded > 0 ? 'warning' : 'error',
message: `成功 ${result.succeeded} 个班,失败 ${failures.length} 个班|${detail}`,
duration: 8000,
showClose: true,
});
}
// 全部失败时把弹窗留着,方便老师改科目/改班级后直接重试
bulkVisible.value = result.succeeded === 0;
if (result.succeeded > 0) await loadHomeworks();
} finally {
bulkSending.value = false;
}
}
async function removeHomework(row: HomeworkDto): Promise<void> {
await ElMessageBox.confirm(`删除作业「${row.title}」?`, '确认', { type: 'warning' });
await homeworkApi.remove(row.id);
@@ -414,6 +524,7 @@ onUnmounted(() => {
@clear="loadHomeworks"
/>
<el-button type="primary" :icon="'Plus'" @click="openCreate">发布作业</el-button>
<el-button @click="openBulk">批量布置</el-button>
</div>
</div>
@@ -460,10 +571,18 @@ onUnmounted(() => {
:loading="formCoursesLoading"
style="width: 100%"
>
<el-option-group v-if="formCourses.length" label="已有课程">
<el-option v-for="item in formCourses" :key="item.id" :label="item.name" :value="item.id" />
<el-option-group v-if="ownFormCourses.length" label="我的科目">
<el-option
v-for="item in ownFormCourses"
:key="item.id"
:label="item.name"
:value="item.id"
/>
</el-option-group>
<el-option-group v-if="!formCoursesLoading && newSubjectOptions.length" label="其他科目(新建)">
<el-option-group
v-if="canCreateCourse && !formCoursesLoading && newSubjectOptions.length"
label="其他科目(新建)"
>
<el-option
v-for="name in newSubjectOptions"
:key="`new-${name}`"
@@ -476,7 +595,9 @@ onUnmounted(() => {
{{
formCoursesLoading
? '正在加载该班课程…'
: '该班还没有的科目在「其他科目(新建)」里,选中后会自动建课再发布(需班主任/管理员)'
: canCreateCourse
? '只列你任教的科目;该班还没有的科目在「其他科目(新建)」里,选中后自动建课再发布'
: '只列你任教的科目;需要别的科目请先由班主任/管理员在课表管理里建好并分配任课老师'
}}
</div>
</el-form-item>
@@ -506,6 +627,69 @@ onUnmounted(() => {
</template>
</el-dialog>
<!-- 批量布置:多班同发同一份作业;科目按名称匹配,某个班没有这门课只让那个班失败 -->
<el-dialog v-model="bulkVisible" title="批量布置作业" width="560px">
<el-form label-width="90px">
<el-form-item label="目标班级" required>
<el-select
v-model="bulkForm.classIds"
multiple
filterable
collapse-tags
collapse-tags-tooltip
placeholder="可多选;一次布置到所有选中班级"
style="width: 100%"
>
<el-option v-for="item in classes" :key="item.id" :label="item.name" :value="item.id" />
</el-select>
</el-form-item>
<el-form-item label="所属科目">
<el-select
v-model="bulkForm.subjectName"
placeholder="不指定科目(仅班主任/管理员可用)"
clearable
filterable
style="width: 100%"
>
<el-option v-for="name in SUBJECT_CATALOG" :key="name" :label="name" :value="name" />
</el-select>
<div class="form-hint">
按科目名称匹配:服务端在每个班里找同名课程,某个班没有这门课时只有那个班失败(不会自动建课)
</div>
</el-form-item>
<el-form-item label="所属日期">
<el-date-picker
v-model="bulkForm.assignDate"
type="date"
value-format="YYYY-MM-DD"
:cell-class-name="dayCellClass"
style="width: 200px"
/>
</el-form-item>
<el-form-item label="标题" required>
<el-input v-model="bulkForm.title" maxlength="120" show-word-limit />
</el-form-item>
<el-form-item label="内容" required>
<el-input
v-model="bulkForm.content"
type="textarea"
:rows="5"
maxlength="5000"
show-word-limit
/>
</el-form-item>
<el-form-item label="附件链接">
<el-input v-model="bulkForm.attachmentUrl" placeholder="https://..." />
</el-form-item>
</el-form>
<template #footer>
<el-button @click="bulkVisible = false">取消</el-button>
<el-button type="primary" :loading="bulkSending" @click="submitBulk">
发布到 {{ bulkForm.classIds.length }} 个班级
</el-button>
</template>
</el-dialog>
<el-drawer v-model="detailVisible" size="46%" :title="current?.title ?? '作业详情'">
<template v-if="current">
<el-descriptions :column="detailColumns" border size="small">
@@ -81,6 +81,41 @@ async function submit(): Promise<void> {
border-radius: 14px;
padding: 30px 28px 22px;
box-shadow: 0 18px 40px rgba(15, 30, 50, 0.28);
/*
* 登录卡片**永远按浅色渲染**。
*
* 页面底色是刻意固定的深色渐变(AGENTS.md §5 第 46 条),卡片按设计就是"深底白卡"。
* 但卡片的内部颜色原本会随 `html.dark` 变:Element Plus 的深色 css-vars 与 `--ch-*`
* 是挂在 `<html>` 上的,照常继承进白卡片 —— 于是深色主题下出现"白卡片 + 深色输入框 +
* 浅灰字"的黑白混搭(用户反馈的「登录页出现黑夜白天模式混合显示」)。
* 这里把卡片范围内的语义色与关键 --el-* 变量钉回浅色值;原生控件也一并声明为 light。
*/
color-scheme: light;
--ch-surface: #ffffff;
--ch-surface-alt: #f7f9fc;
--ch-surface-sunken: #f2f3f5;
--ch-surface-hover: #e6e8eb;
--ch-border: #e6e8ef;
--ch-text: #303133;
--ch-text-secondary: #606266;
--ch-text-muted: #909399;
--ch-text-placeholder: #c0c4cc;
--el-bg-color: #ffffff;
--el-bg-color-overlay: #ffffff;
--el-bg-color-page: #f2f4f8;
--el-text-color-primary: #303133;
--el-text-color-regular: #606266;
--el-text-color-secondary: #909399;
--el-text-color-placeholder: #c0c4cc;
--el-text-color-disabled: #a8abb2;
--el-fill-color-blank: #ffffff;
--el-fill-color-light: #f2f3f5;
--el-fill-color-lighter: #f5f7fa;
--el-fill-color: #f2f3f5;
--el-border-color: #e6e8ef;
--el-border-color-light: #e6e8ef;
--el-border-color-lighter: #e6e8ef;
--el-color-primary: #409eff;
/*
* 入场用 PANEL 弹簧(beUI 的 center-morph-modal 观感:从略小、略高处落下来)。
* 登录页是整个应用里最"一次性"、最值得给一点分量的一屏 ——
@@ -13,6 +13,8 @@ import {
truncate,
type ClassDto,
type ClassPeriod,
type NotificationCreatorSummary,
type NotificationDaySummary,
type NotificationDto,
type NotificationPriority,
type StudentDto,
@@ -27,7 +29,38 @@ const route = useRoute();
const loading = ref(false);
const classes = ref<ClassDto[]>([]);
const notifications = ref<NotificationDto[]>([]);
const filter = reactive({ classId: '', priority: '', keyword: '' });
const filter = reactive({ classId: '', priority: '', keyword: '', date: '', createdBy: '' });
/**
* 按天归档 / 按发布人归档的候选列表(需求:通知按天归档,也可按发布人、类型看)。
*
* 两者跟着"班级 + 优先级"走:班级一换,日期栏与发布人栏就应该只剩那个班里真实存在的
* 日期与人 —— 否则选项里全是别的班级的数据,选中后得到空列表,看着像坏了。
* 发布人栏还额外跟着当前选中的日期收敛("这一天都有谁发过通知")。
*/
const days = ref<NotificationDaySummary[]>([]);
const creators = ref<NotificationCreatorSummary[]>([]);
async function loadArchive(): Promise<void> {
const base = {
...(filter.classId ? { classId: filter.classId } : {}),
...(filter.priority ? { priority: filter.priority } : {}),
};
const [dayList, creatorList] = await Promise.all([
notificationApi.days(base).catch(() => ({ days: [] as NotificationDaySummary[] })),
notificationApi
.creators({ ...base, ...(filter.date ? { date: filter.date } : {}) })
.catch(() => ({ creators: [] as NotificationCreatorSummary[] })),
]);
days.value = dayList.days;
creators.value = creatorList.creators;
}
/** 筛选变化后统一刷新:先更新归档候选,再拉当前筛选下的列表 */
async function refreshList(): Promise<void> {
await loadArchive();
await loadNotifications();
}
/**
* 是否"单班视图":选中了具体班级时列表只服务一个班。
@@ -65,10 +98,18 @@ async function loadClassStudentCounts(): Promise<void> {
async function loadNotifications(): Promise<void> {
loading.value = true;
try {
const params: { classId?: string; priority?: string; keyword?: string } = {};
const params: {
classId?: string;
priority?: string;
keyword?: string;
date?: string;
createdBy?: string;
} = {};
if (filter.classId) params.classId = filter.classId;
if (filter.priority) params.priority = filter.priority;
if (filter.keyword.trim()) params.keyword = filter.keyword.trim();
if (filter.date) params.date = filter.date;
if (filter.createdBy) params.createdBy = filter.createdBy;
notifications.value = await notificationApi.list(params);
} finally {
loading.value = false;
@@ -236,48 +277,34 @@ interface PublishFailure {
}
/**
* 真正提交:对每个班级各调一次 `POST /api/notifications`(Promise.allSettled),
* confirmDuringClass 为 true 表示教师已在上课警告中确认。
* 真正提交:调用服务端的**批量发布**端点(`POST /api/notifications/bulk`)一次提交,
* 服务端逐班做权限断言与上课保护,并把每个班的结果回给我们。
*
* 为什么不再由前端对每个班各发一次请求:N 个班就是 N 次往返,权限/上课保护/ClassIsland 推送
* 分散在 N 个响应里,前端还得自己合并;服务端批量端点把这些收敛成一份逐班结果(见 AGENTS.md §5)。
* confirmDuringClass 为 true 表示教师已在上课警告里确认。
*/
async function doPublish(classIds: string[], confirmDuringClass: boolean): Promise<void> {
if (classIds.length === 0) return;
const payload = {
const result = await notificationApi.bulkCreate({
classIds,
title: form.title.trim(),
content: form.content,
priority: form.priority,
...(confirmDuringClass ? { confirmDuringClass: true } : {}),
};
const settled = await Promise.allSettled(
classIds.map((classId) => notificationApi.create({ ...payload, classId })),
);
let successCount = 0;
const failures: PublishFailure[] = [];
settled.forEach((result, index) => {
if (result.status === 'fulfilled') {
successCount += 1;
return;
}
const response = (
result.reason as {
response?: {
status?: number;
data?: { code?: string; message?: string; details?: { current?: ClassPeriod | null } };
};
}
).response;
failures.push({
classId: classIds[index] ?? '',
reason:
response?.data?.message ?? (result.reason instanceof Error ? result.reason.message : '发布失败'),
urgentConflict: response?.status === 409 && response?.data?.code === 'URGENT_DURING_CLASS',
period: response?.data?.details?.current ?? null,
});
});
const successCount = result.succeeded;
const failures: PublishFailure[] = result.results
.filter((item) => !item.ok)
.map((item) => ({
classId: item.classId,
reason: item.message ?? '发布失败',
urgentConflict: item.code === 'URGENT_DURING_CLASS',
period: ((item.details ?? {}) as { current?: ClassPeriod | null }).current ?? null,
}));
// 兜底:并发场景下服务端仍可能拦截(例如刚好上课铃响),对这批班级重新走一次二次确认
const conflicted = failures.filter((item) => item.urgentConflict);
const pendingConfirm = !confirmDuringClass && conflicted.length > 0;
@@ -296,7 +323,7 @@ async function doPublish(classIds: string[], confirmDuringClass: boolean): Promi
// 注意这里是 pendingConfirm 而不是 !pendingConfirm —— 写成取反会让弹窗在**发布成功后仍然开着**,
// 老师以为没发出去再点一次「立即发布」,同一批班级就重复收到通知(还会重复广播与推 ClassIsland)。
formVisible.value = pendingConfirm;
await loadNotifications();
await refreshList();
}
}
@@ -363,7 +390,7 @@ function rowClassName({ row }: { row: NotificationDto }): string {
onMounted(async () => {
await loadClasses();
await loadNotifications();
await refreshList();
realtime.on(SOCKET_EVENTS.notificationNew, onNotificationEvent);
// 列表渲染完再滚动,否则表格行还没生成
if (highlightedId.value) {
@@ -390,7 +417,7 @@ onUnmounted(() => {
placeholder="选择班级"
clearable
style="width: 170px"
@change="loadNotifications"
@change="refreshList"
>
<el-option v-for="item in classes" :key="item.id" :label="item.name" :value="item.id" />
</el-select>
@@ -399,7 +426,7 @@ onUnmounted(() => {
placeholder="全部优先级"
clearable
style="width: 150px"
@change="loadNotifications"
@change="refreshList"
>
<el-option
v-for="item in NOTIFICATION_PRIORITIES"
@@ -408,6 +435,36 @@ onUnmounted(() => {
:value="item"
/>
</el-select>
<!-- 按天归档:只列当前班级/优先级下真实存在的日期与条数 -->
<el-select
v-model="filter.date"
placeholder="按天归档"
clearable
style="width: 170px"
@change="refreshList"
>
<el-option
v-for="item in days"
:key="item.date"
:label="`${item.date}(${item.count})`"
:value="item.date"
/>
</el-select>
<!-- 按发布人归档:跟着班级/优先级/日期收敛 -->
<el-select
v-model="filter.createdBy"
placeholder="全部发布人"
clearable
style="width: 160px"
@change="loadNotifications"
>
<el-option
v-for="item in creators"
:key="item.id"
:label="`${item.name}(${item.count})`"
:value="item.id"
/>
</el-select>
<el-input
v-model="filter.keyword"
placeholder="搜索标题/内容"
@@ -452,6 +509,12 @@ onUnmounted(() => {
<div class="text-muted">{{ relativeTime(row.createdAt) }}</div>
</template>
</el-table-column>
<!-- 所属日期:按天归档用的口径(本地日期),晚间发布不会被算到第二天 -->
<el-table-column label="所属日期" width="120">
<template #default="{ row }">
<el-tag size="small" effect="plain">{{ row.assignDate }}</el-tag>
</template>
</el-table-column>
<el-table-column :label="isSingleClass ? '已读情况' : '已读率'" width="150">
<template #default="{ row }">
<!--
@@ -489,7 +552,7 @@ onUnmounted(() => {
filterable
collapse-tags
collapse-tags-tooltip
placeholder="可多选;发布时逐班提交"
placeholder="可多选;一次发布到所有选中班级"
style="width: 100%"
>
<el-option v-for="item in classes" :key="item.id" :label="item.name" :value="item.id" />
@@ -0,0 +1,614 @@
<script setup lang="ts">
/**
* 权限组管理(对应需求「允许 admin 设置各用户权限,或创建权限组」)。
*
* 两个 Tab:
* 1. **权限组**:新建 / 编辑 / 删除权限组(一组权限键),内置组只允许改、禁止删;
* 2. **成员**:把管理员 / 教师账号分配到权限组(不选任何组 = 回到角色默认模板)。
*
* 权限规则本身**不在这里实现**(AGENTS.md §5 第 3 条):本页只是把服务端
* `GET /permissions/catalog` 给的目录、以及 `lib/permissions.ts` 的生效规则
* 如实展示出来,真正的判定始终在服务端 —— 页面拿到的 `fromGroups` / `permissionCount`
* 都是服务端算好的结果。
*/
import { computed, onMounted, reactive, ref } from 'vue';
import { ElMessage, ElMessageBox } from 'element-plus';
import {
ROLE_LABELS,
type PermissionCatalogDto,
type PermissionGroupDto,
type PermissionKey,
type PermissionMemberDto,
type UserRole,
} from '@classhelper/shared';
import { permissionApi } from '@/api';
import { useAuthStore } from '@/stores/auth';
import { useResponsive } from '@/composables/useResponsive';
const { isMobile } = useResponsive();
const auth = useAuthStore();
/** 当前 Tab:权限组 / 成员 */
const activeTab = ref<'groups' | 'members'>('groups');
const loading = ref(false);
/** 加载失败的中文提示(非空 = 页面顶部显示错误态 + 重试按钮) */
const loadError = ref('');
const groups = ref<PermissionGroupDto[]>([]);
const members = ref<PermissionMemberDto[]>([]);
const catalog = ref<PermissionCatalogDto | null>(null);
/** 当前账号的生效权限数(还没拉回来时用 null 表示"未知",不显示 0) */
const myPermissionCount = computed(() => (auth.permissionsLoaded ? auth.permissions.length : null));
/** 权限键总数(弹窗标题里的分母) */
const catalogKeyCount = computed(() => catalog.value?.keys.length ?? 0);
/** 组 id → 组名(成员表把 groupIds 翻成名字) */
const groupNameMap = computed<Record<string, string>>(() => {
const map: Record<string, string> = {};
for (const group of groups.value) map[group.id] = group.name;
return map;
});
function roleLabel(role: UserRole): string {
return ROLE_LABELS[role];
}
/**
* 从错误里取服务端的中文提示(取不到就退回 axios/浏览器的 message)。
*
* 注意 `http.ts` 的响应拦截器**已经**为带响应的错误弹过一次 `ElMessage.error`,
* 所以这里只负责"拿文案",不再自己弹一遍 —— 见 {@link toastError}。
*/
function errorMessage(error: unknown): string {
const response = (error as { response?: { data?: { message?: string } } } | null)?.response;
const serverMessage = response?.data?.message;
if (serverMessage) return serverMessage;
if (error instanceof Error && error.message) return error.message;
return '请求失败';
}
/**
* 补一次失败提示。
*
* 只给"压根没拿到响应"的那一类(断网、超时、被 CSP 拦掉)补提示:带响应的错误
* 拦截器已经弹过,这里再弹一次就会在屏幕上叠两条一模一样的 toast。有响应的错误
* 落到页面内的错误态(`loadError`)。
*/
function toastError(error: unknown): void {
if (!(error as { response?: unknown } | null)?.response) ElMessage.error(errorMessage(error));
}
/**
* 拉全部数据:权限组 + 成员 + 权限目录(目录只在首次拉,之后复用)。
*
* 一并刷新 `auth.ensurePermissions(true)`:顶栏那句"权限来自权限组 / 角色默认模板"
* 必须是最新的(服务端每次请求实时算权限,改了立刻生效)。
*/
async function loadAll(): Promise<void> {
loading.value = true;
loadError.value = '';
try {
const [groupList, memberList, catalogData] = await Promise.all([
permissionApi.listGroups(),
permissionApi.listMembers(),
catalog.value ? Promise.resolve(catalog.value) : permissionApi.catalog(),
]);
groups.value = groupList;
members.value = memberList;
catalog.value = catalogData;
await auth.ensurePermissions(true);
} catch (error) {
loadError.value = errorMessage(error);
toastError(error);
} finally {
loading.value = false;
}
}
onMounted(() => {
void loadAll();
});
/* -------------------------------------------------------------- 权限组:新建 / 编辑 */
/** 新建与编辑共用的弹窗状态(`id` 为空串 = 新建) */
const groupDialog = reactive({
visible: false,
id: '',
name: '',
description: '',
keys: [] as PermissionKey[],
saving: false,
});
const isEditingGroup = computed(() => Boolean(groupDialog.id));
const groupDialogTitle = computed(() => (isEditingGroup.value ? '编辑权限组' : '新建权限组'));
const groupKeysLabel = computed(() => `权限键(已选 ${groupDialog.keys.length} / ${catalogKeyCount.value})`);
function openCreateGroup(): void {
groupDialog.id = '';
groupDialog.name = '';
groupDialog.description = '';
groupDialog.keys = [];
groupDialog.visible = true;
}
function openEditGroup(group: PermissionGroupDto): void {
groupDialog.id = group.id;
groupDialog.name = group.name;
groupDialog.description = group.description;
// 复制一份:取消/关闭时不能污染表格里的数据
groupDialog.keys = [...group.keys];
groupDialog.visible = true;
}
/**
* 该键"默认给哪些角色"(来自目录的 `defaultRoles`,与服务端
* `lib/permissions.ts` 的角色默认模板同源)。空数组 = 谁都不默认给。
*/
function defaultRoleHint(key: PermissionKey): string {
const roles = catalog.value?.defaultRoles[key] ?? [];
if (roles.length === 0) return '默认不给任何角色';
return `默认给:${roles.map((role) => ROLE_LABELS[role]).join('、')}`;
}
/**
* 是否为"管理员不可被剥夺"的键(目录里的 `unremovable`)。
*
* **故意不禁用勾选框**:这两个键(`permission:manage` / `system:manage`)的真实语义是
* "管理员账号永远保留",而不是"权限组里不能勾" —— 把 `permission:manage` 授给一个权限组
* 恰恰是本功能的正当用法(让某位老师帮忙管权限),禁掉等于让这条链路没法配。
* 这里只打一个「高权限」标记提醒配置的人。
*/
function isHighPrivilege(key: PermissionKey): boolean {
return catalog.value?.unremovable.includes(key) ?? false;
}
/** 分类勾选状态:全选 / 全不选 / 选了一部分(决定"全选-清空"按钮的文案) */
function categoryState(keys: PermissionKey[]): 'all' | 'none' | 'part' {
const selected = keys.filter((key) => groupDialog.keys.includes(key)).length;
if (selected === 0) return 'none';
return selected === keys.length ? 'all' : 'part';
}
/** 整个分类一起勾 / 一起取消(40 个键一个个点太累) */
function toggleCategory(keys: PermissionKey[]): void {
if (categoryState(keys) === 'all') {
groupDialog.keys = groupDialog.keys.filter((key) => !keys.includes(key));
return;
}
const merged = new Set<PermissionKey>(groupDialog.keys);
for (const key of keys) merged.add(key);
groupDialog.keys = Array.from(merged);
}
async function submitGroup(): Promise<void> {
const name = groupDialog.name.trim();
if (!name) {
ElMessage.warning('请填写权限组名称');
return;
}
// 先在前端拦一次重名(服务端也会 409),错误提示能更早出现
if (groups.value.some((group) => group.id !== groupDialog.id && group.name === name)) {
ElMessage.warning(`已存在名为「${name}」的权限组`);
return;
}
groupDialog.saving = true;
try {
const payload = {
name,
description: groupDialog.description.trim(),
// 传了就**整体替换**(服务端契约),所以这里始终带上完整勾选结果
keys: [...groupDialog.keys],
};
if (isEditingGroup.value) {
await permissionApi.updateGroup(groupDialog.id, payload);
ElMessage.success('权限组已更新,组内成员立即生效');
} else {
await permissionApi.createGroup(payload);
ElMessage.success('权限组已创建');
}
groupDialog.visible = false;
await loadAll();
} catch (error) {
toastError(error);
} finally {
groupDialog.saving = false;
}
}
async function removeGroup(group: PermissionGroupDto): Promise<void> {
// 按钮已经 disabled,这里只是兜底(服务端也会 400)
if (group.builtin) return;
const memberHint =
group.memberCount > 0
? `组内 ${group.memberCount} 名成员会回到角色默认权限(不会变成无权限)。`
: '该组目前没有成员。';
try {
await ElMessageBox.confirm(`删除权限组「${group.name}」?${memberHint}`, '确认删除', {
type: 'warning',
confirmButtonText: '删除',
cancelButtonText: '取消',
});
} catch {
return; // 用户取消
}
try {
await permissionApi.removeGroup(group.id);
ElMessage.success('已删除');
await loadAll();
} catch (error) {
toastError(error);
}
}
/* -------------------------------------------------------------- 成员:分配权限组 */
const assignDialog = reactive({
visible: false,
member: null as PermissionMemberDto | null,
groupIds: [] as string[],
saving: false,
});
function openAssign(member: PermissionMemberDto): void {
if (member.fixed) return; // 管理员固定拥有全部权限(服务端同样 400)
assignDialog.member = member;
assignDialog.groupIds = [...member.groupIds];
assignDialog.visible = true;
}
/** 该成员角色"不选任何组"时会拿到多少项权限(目录里的 `roleDefaults`) */
const roleDefaultCount = computed(() => {
const role = assignDialog.member?.role;
if (!role || !catalog.value) return 0;
return catalog.value.roleDefaults[role].length;
});
async function submitAssign(): Promise<void> {
const member = assignDialog.member;
if (!member) return;
assignDialog.saving = true;
try {
// 空数组 = 回到角色默认模板(服务端契约)
await permissionApi.assignGroups(member.id, { groupIds: [...assignDialog.groupIds] });
ElMessage.success('已更新该成员的权限组,立即生效');
assignDialog.visible = false;
await loadAll();
} catch (error) {
toastError(error);
} finally {
assignDialog.saving = false;
}
}
</script>
<template>
<div class="page">
<div class="page-header">
<div>
<h2 class="page-title">权限组管理</h2>
<p class="page-subtitle">
创建权限组并把账号分配进去,用来给老师额外开通某项能力(也可以反过来收回权限)。
</p>
</div>
</div>
<!--
生效规则说明:这一句是页面的"图例",两端的生效逻辑都按它来
(服务端 lib/permissions.ts 的 loadEffectivePermissions)。
-->
<el-alert class="perm-banner" type="info" :closable="false" show-icon>
<template #title>
权限生效规则:有权限组时取各组的并集;没有任何组时使用角色默认模板。
</template>
<template #default>
当前账号:{{ auth.roleLabel }}
<template v-if="myPermissionCount !== null"> · 生效权限 {{ myPermissionCount }} 项</template>
· {{ auth.permissionsFromGroups ? '权限来自权限组' : '未分配权限组(走角色默认模板)' }}
</template>
</el-alert>
<!-- 错误态:拦截器已经弹过一次 toast,这里给一个能重试的落点 -->
<el-alert v-if="loadError" class="perm-banner" type="error" :closable="false" show-icon>
<template #title>权限数据加载失败:{{ loadError }}</template>
<template #default>
<el-button link type="primary" @click="loadAll">重试</el-button>
</template>
</el-alert>
<el-tabs v-model="activeTab">
<!-- ------------------------------------------------ Tab 1:权限组 -->
<el-tab-pane label="权限组" name="groups">
<div class="toolbar tab-toolbar">
<el-button type="primary" :icon="'Plus'" @click="openCreateGroup">新建权限组</el-button>
<span class="text-muted">内置权限组由系统预置,可以改名与调整权限,但不能删除。</span>
</div>
<el-card shadow="never" class="table-card">
<el-table v-loading="loading" :data="groups" empty-text="暂无权限组">
<el-table-column prop="name" label="名称" min-width="150" show-overflow-tooltip />
<el-table-column label="描述" min-width="200" show-overflow-tooltip>
<template #default="{ row }">
<span v-if="row.description">{{ row.description }}</span>
<span v-else class="text-muted">(无描述)</span>
</template>
</el-table-column>
<el-table-column label="权限数" width="90">
<template #default="{ row }">{{ row.keys.length }}</template>
</el-table-column>
<el-table-column label="成员数" width="90">
<template #default="{ row }">{{ row.memberCount }}</template>
</el-table-column>
<el-table-column label="类型" width="100">
<template #default="{ row }">
<el-tag size="small" effect="plain" :type="row.builtin ? 'info' : 'primary'">
{{ row.builtin ? '内置' : '自定义' }}
</el-tag>
</template>
</el-table-column>
<el-table-column label="操作" width="140">
<template #default="{ row }">
<el-button link type="primary" @click="openEditGroup(row)">编辑</el-button>
<!-- 内置组禁止删除:按钮 disabled + tooltip 说明(disabled 元素不发光标事件,外面套一层 span) -->
<el-tooltip :disabled="!row.builtin" content="内置权限组不能删除" placement="top">
<span>
<el-button link type="danger" :disabled="row.builtin" @click="removeGroup(row)">
删除
</el-button>
</span>
</el-tooltip>
</template>
</el-table-column>
</el-table>
</el-card>
</el-tab-pane>
<!-- ------------------------------------------------ Tab 2:成员 -->
<el-tab-pane label="成员" name="members">
<div class="toolbar tab-toolbar">
<span class="text-muted">
只列出管理员与教师账号;管理员固定拥有全部权限,不能被分配权限组。
</span>
</div>
<el-card shadow="never" class="table-card">
<el-table v-loading="loading" :data="members" empty-text="暂无成员">
<el-table-column prop="name" label="姓名" min-width="120" show-overflow-tooltip />
<el-table-column prop="username" label="用户名" min-width="120" show-overflow-tooltip />
<el-table-column label="角色" width="130">
<template #default="{ row }">{{ roleLabel(row.role) }}</template>
</el-table-column>
<el-table-column label="所属权限组" min-width="200">
<template #default="{ row }">
<template v-if="row.groupIds.length">
<el-tag
v-for="groupId in row.groupIds"
:key="groupId"
class="perm-tag"
size="small"
effect="plain"
>
{{ groupNameMap[groupId] ?? '(权限组已删除)' }}
</el-tag>
</template>
<span v-else class="text-muted">角色默认模板</span>
</template>
</el-table-column>
<el-table-column label="生效权限数" width="110">
<template #default="{ row }">{{ row.permissionCount }}</template>
</el-table-column>
<el-table-column label="操作" width="130">
<template #default="{ row }">
<el-tooltip :disabled="!row.fixed" content="管理员固定拥有全部权限" placement="top">
<span>
<el-button link type="primary" :disabled="row.fixed" @click="openAssign(row)">
分配权限组
</el-button>
</span>
</el-tooltip>
</template>
</el-table-column>
</el-table>
</el-card>
</el-tab-pane>
</el-tabs>
<!-- ------------------------------------------------ 新建 / 编辑权限组 -->
<el-dialog
v-model="groupDialog.visible"
:title="groupDialogTitle"
:width="isMobile ? '92%' : '720px'"
:close-on-click-modal="false"
>
<el-form label-position="top">
<el-form-item label="名称" required>
<el-input
v-model="groupDialog.name"
maxlength="30"
show-word-limit
placeholder="例如:教务协助、机房值班"
/>
</el-form-item>
<el-form-item label="描述">
<el-input
v-model="groupDialog.description"
maxlength="100"
placeholder="这个权限组是做什么的(可留空)"
/>
</el-form-item>
<el-form-item :label="groupKeysLabel">
<div class="perm-picker">
<div v-for="category in catalog?.categories ?? []" :key="category.title" class="perm-category">
<div class="perm-category-head">
<span class="perm-category-title">{{ category.title }}</span>
<el-button link type="primary" size="small" @click="toggleCategory(category.keys)">
{{ categoryState(category.keys) === 'all' ? '清空' : '全选' }}
</el-button>
</div>
<!-- 每个分类一个 checkbox-group,但共用同一个 keys 数组 -->
<el-checkbox-group v-model="groupDialog.keys" class="perm-keys">
<div v-for="key in category.keys" :key="key" class="perm-key">
<el-checkbox :value="key">
{{ catalog?.labels[key] ?? key }}
<el-tag
v-if="isHighPrivilege(key)"
class="perm-flag"
size="small"
type="warning"
effect="plain"
>
高权限
</el-tag>
</el-checkbox>
<span class="perm-hint">{{ defaultRoleHint(key) }}</span>
</div>
</el-checkbox-group>
</div>
</div>
<p class="perm-note text-muted">
保存时会整体替换该组的权限键(取消勾选 = 收回这项权限);不填任何键则该组成员没有任何权限。
</p>
</el-form-item>
</el-form>
<template #footer>
<el-button @click="groupDialog.visible = false">取消</el-button>
<el-button type="primary" :loading="groupDialog.saving" @click="submitGroup">保存</el-button>
</template>
</el-dialog>
<!-- ------------------------------------------------ 给成员分配权限组 -->
<el-dialog
v-model="assignDialog.visible"
title="分配权限组"
:width="isMobile ? '92%' : '520px'"
:close-on-click-modal="false"
>
<template v-if="assignDialog.member">
<p class="assign-member">
{{ assignDialog.member.name }}({{ assignDialog.member.username }} ·
{{ roleLabel(assignDialog.member.role) }})
</p>
<el-select
v-model="assignDialog.groupIds"
class="assign-select"
multiple
clearable
filterable
placeholder="不选任何组 = 使用角色默认模板"
>
<el-option v-for="group in groups" :key="group.id" :label="group.name" :value="group.id">
<span>{{ group.name }}</span>
<span class="text-muted">({{ group.keys.length }} 项权限)</span>
</el-option>
</el-select>
<p class="assign-hint text-muted">
不选任何组 = 使用角色默认模板({{ roleLabel(assignDialog.member.role) }} 默认
{{ roleDefaultCount }} 项权限);选了组就取各组权限的并集。
</p>
</template>
<template #footer>
<el-button @click="assignDialog.visible = false">取消</el-button>
<el-button type="primary" :loading="assignDialog.saving" @click="submitAssign">保存</el-button>
</template>
</el-dialog>
</div>
</template>
<style scoped>
/* 顶部两条横幅(生效规则 / 错误态):圆角与底都用设计令牌,不写死数值 */
.perm-banner {
margin-bottom: 12px;
border-radius: var(--ch-radius-sm);
}
.tab-toolbar {
margin-bottom: 12px;
}
/* 权限键勾选区:两列铺开,自己内部滚动,避免弹窗比屏幕还高 */
.perm-picker {
width: 100%;
max-height: 320px;
overflow-y: auto;
padding: 4px 12px 12px;
border: 1px solid var(--ch-border);
border-radius: var(--ch-radius-md);
background: var(--ch-surface-alt);
}
.perm-category + .perm-category {
margin-top: 10px;
}
.perm-category-head {
display: flex;
align-items: center;
justify-content: space-between;
gap: 8px;
padding: 8px 0 2px;
border-bottom: 1px solid var(--ch-border);
}
.perm-category-title {
font-size: 13px;
font-weight: 600;
}
.perm-keys {
display: grid;
grid-template-columns: repeat(2, minmax(0, 1fr));
gap: 2px 16px;
padding-top: 6px;
}
.perm-key {
display: flex;
flex-direction: column;
min-width: 0;
}
.perm-hint {
color: var(--ch-text-muted);
font-size: 11px;
line-height: 1.4;
padding-left: 24px;
}
.perm-flag {
margin-left: 6px;
}
.perm-note {
margin: 8px 0 0;
font-size: 12px;
}
.perm-tag {
margin-right: 6px;
}
.assign-member {
margin: 0 0 10px;
font-size: 13px;
}
.assign-select {
width: 100%;
}
.assign-hint {
margin: 10px 0 0;
font-size: 12px;
line-height: 1.5;
}
/* 小屏(≤768px):勾选区改一列,说明文字与表格卡片同宽 */
@media (max-width: 768px) {
.perm-keys {
grid-template-columns: minmax(0, 1fr);
}
}
</style>
+12 -4
View File
@@ -18,7 +18,7 @@ import {
type ScheduleWeekView,
type WeekParity,
} from '@classhelper/shared';
import { classApi, courseApi, dashboardApi, scheduleApi } from '@/api';
import { classApi, courseApi, courseIdFromExistsError, dashboardApi, scheduleApi } from '@/api';
import ClassPlanImportDialog from '@/components/ClassPlanImportDialog.vue';
import { useAuthStore } from '@/stores/auth';
import { useRealtimeStore } from '@/stores/realtime';
@@ -122,9 +122,17 @@ async function resolveCourseId(): Promise<string | null> {
const name = value.slice(SUBJECT_PREFIX.length);
const existing = courses.value.find((item) => item.name === name);
if (existing) return existing.id;
const created = await courseApi.create({ classId: query.classId, name });
courses.value = [...courses.value, created];
return created.id;
try {
const created = await courseApi.create({ classId: query.classId, name });
courses.value = [...courses.value, created];
return created.id;
} catch (error) {
// 该班已有同名课程(本地列表过期):复用那一门,绝不另建第二门同名的课
// —— 课程创建会把创建者写成任课老师,重复建课正是"把自己变成别人科目的老师"的入口
const reusedId = courseIdFromExistsError(error);
if (!reusedId) throw error;
return reusedId;
}
}
/**