6 Commits
Author SHA1 Message Date
admin 43007cd2d2 docs(changelog): v1.4.1 发布说明(导入核对 tab 风格统一) 2026-09-14 10:28:22 +08:00
admin e92a287a73 refactor(web): 导入核对 tab 与全局风格统一
按用户「现在导入核对是一个内嵌页面,很突兀,是不是改为统一风格好点」。

之前 ReviewWorkbench 是个 dark-theme SPA(自带的 sidebar + brand + 进度环 + main),
被 ReviewView 用 stub 直接渲染,与其它 9 个 tab 的 page-title + card 风格完全割裂,
'独占全屏'地把外层 topbar + tabs + footer 全挤掉。

### 改动
- ReviewWorkbench.vue 去掉 app shell(sidebar / brand / 进度环),分类筛选折叠成
  顶部单行 filter-bar,保留 header + main + log 三段;样式从 dark 改为沿用平台
  浅色(card + #2f6bff 主色 + #059669/d97706/dc2626 状态色),与首页/概览风格一致。
- 状态 select / 操作按钮替换为 el-select / el-button,避免自定义控件风格漂移。
- ReviewView.vue 套 page-title + card 容器,与其它 view 一致。

### 不动的功能
7 项分类筛选、6 项状态筛选、连接/Key 配置、4 张统计卡、详情展开、日志面板、
内置清单导入、MD/JSON 导出、Apply 选中、reset/select-all 等全部保留。
2026-09-14 10:19:49 +08:00
admin 5e2ddf7241 docs(changelog): v1.4.0 发布说明(使用分析 + schema 层审计) 2026-09-11 18:32:43 +08:00
admin 8ed658382f feat(analytics): 使用分析面板 + schema 层审计 + access_log target/保留策略
- access_log 中间件按路由模板映射 target(修复 :name/:id 参数名导致
  /object-types/:name 等路由 target 长期为空);401/4xx 兜底记 deny;
  action 简化为 read/write/delete/manage;新增 90 天保留策略
  (ACCESS_LOG_RETENTION_DAYS 覆盖,0 关闭)
- schema 审计:对象类型/属性/链接类型/链接属性/动作类型/分级配置的
  增删改写入 ontology_audit_log(target_pk 落库,update/delete 带 before 快照);
  存量库补 target_pk 列(幂等 ALTER)
- 新增 /api/v1/analytics/{overview,types,users,sharing}(仅 manager):
  总体读写比/活跃主体/来源分布/按天趋势、分项热度、用户活跃、共享授权使用量
- 前端新增「使用分析」tab(AnalyticsView)
2026-09-11 18:23:47 +08:00
admin 15d0893522 docs(changelog): v1.3.6 发布说明([Unreleased] 定版 issue #8 MCP 读路径真实身份) 2026-09-07 18:41:14 +08:00
admin 6841712289 fix(mcp): 读路径透传调用方真实身份(issue #8 v2)
按用户反馈「每个主体都有 mcp 访问 key,就应该是各自主体身份」——
v1 方案「注入 connector key + 手动 X-Principal」本质是「模拟身份」,
绕开了主体解析链。v2 改为透传调用方真实鉴权。

### 改动
- callConn 接受源 *gin.Context,透传 X-API-Key / session cookie 给内层请求,
  让 principalFromRequest 自然解析到 manager / connector / analyst / 等。
- connectorAuth 放宽到「任一主体 api_key 即放行」:
  - 移除 WHERE name='connector' 的硬约束
  - 助手 anyPrincipalKeySet() 判断全库是否已有密钥(有则要求带 key,无则放行兼容无密钥只读)
- 6 个调用点去掉 principal 参数,改传 c。

### 影响
- 之前:MCP 读工具一律以 connector 执行,manager 走 MCP 只能看 L0-L2。
- 现在:各主体按自己 clearance 视图读,manager 走 MCP 见全部分级(含 L3)。
- callConn 路径与 connectorAuth 路径身份解析统一(都走 principalFromRequest 自然解析)。

### 验证
- 3 个新集成测试全绿(issue8_mcp_read_principal_test.go):
  按 connector / manager / analyst 三种 api_key 调 MCP get_objects_by_type,
  分别见 2 / 3 / 1 条(符合各自 clearance)。
- 既有 issue #6/#7 的 6 个测试 + SetObjectTypeClassification 全绿。

### CHANGELOG 风格
按用户反馈「只有改了什么 / 有什么影响,不要流水账」,
重写 [Unreleased] / [1.3.3] / [1.3.2] 三段:每段只留「影响 + 改动 [+ 设计]」,
去掉过程叙述、commit hash、调试日志、issue 评论引用等。
2026-09-07 18:36:21 +08:00
18 changed files with 1714 additions and 341 deletions

No files matched your search

+35 -50
View File
@@ -18,64 +18,49 @@ AI 客户端在使用本平台过程中发现 bug 或有改进建议,**请提
## 版本历史
## [1.4.1] - 2026-09-14 导入核对 tab 与全局风格统一
**改动**:ReviewWorkbench(导入核对)去掉内嵌 dark-theme SPA 外壳(sidebar/brand/进度环),改为与其它 tab 一致的 page-title + card 浅色风格;筛选折叠为顶部单行 filter-bar,状态 select/操作按钮替换为 el-select/el-button。7 项分类筛选、6 项状态筛选、连接/Key 配置、统计卡、详情展开、日志、清单导入、MD/JSON 导出、Apply 等功能全部保留。
## [1.4.0] - 2026-09-11 使用分析 + schema 层审计
**影响**:本体定义(类型/属性/链接类型等)的增删改此前只有 access_log 的 method+path 间接痕迹,无 before/after;使用/浏览情况无法按本体分项统计(:name 参数路由的 target 长期为空)。
**改动**:
- **schema 审计**:对象类型/属性/链接类型/链接属性/动作类型/分级配置的增删改写入 `ontology_audit_log`(target_pk 落库,update/delete 带 before 快照);存量库幂等补 `target_pk` 列。
- **access_log 中间件**:按路由模板映射 target(修复 `:name`/`:id` 参数名导致 target 为空);4xx 响应兜底记 `deny`;action 归一为 read/write/delete/manage。
- **保留策略**:access_log 默认保留 90 天(`ACCESS_LOG_RETENTION_DAYS` 覆盖,0 关闭),启动时 + 每 24h 清理。
- **使用分析 API**(仅 manager):`GET /api/v1/analytics/overview|types|users|sharing` —— 总体读写比/活跃主体/来源分布/按天趋势、分项热度、用户活跃、共享授权使用量,全部现算不建新表。
- **前端**:新增「使用分析」tab(指标卡 + 按天趋势柱图 + 分项热度/用户活跃/共享明细表,7/30/90 天切换)。
## [1.3.6] - 2026-09-07 MCP 读路径按真实调用者解析主体(issue #8)
**影响**:MCP 读工具(get_objects_by_type / get_object / query_related / search_ontology / get_object_types / get_facets)此前一律以 connector 主体执行,manager 走 MCP 只能看 connector clearance (L0-L2) 下的数据;现已按调用者真实 api_key 解析主体。
**改动**:
- `callConn` 改为透传调用方 `X-API-Key` / session cookie,让 `principalFromRequest` 自然解析主体;不再注入 connector key + 手动 X-Principal(之前是「模拟身份」)。
- `connectorAuth` 放宽:接受任何主体的 api_key(不再只接 connector key)。连接器入口 = 任何已认证主体;可见性仍由读路径 classification filter 按各自 clearance 控制。
**顺带**:`PUT /access/principals/:name` 只传 description 时响应 `has_api_key` 误报 false 已修复(读取 DB 真实状态回显)。
## [1.3.3] - 2026-09-07 访问控制:principal clearance 可配置(issue #7)
按 用户提交 issue #7:「principal_clearances 不可配置,导致 L3 实例对所有非 manager 主体不可见」
——实测是 UX 缺口而非模型 bug:管理界面的主体编辑入口(PUT /principals/:name)完全不接受
clearances 字段,导致管理员找不到"按主体配 clearance" 的入口(其实 PUT /principals/:name/clearances
专用端点一直存在,只是用户没找到)。
**影响**:之前管理员无法通过 `PUT /principals/:name` 配置 clearance(字段被静默忽略),主体 clearance 列表接口也不回显;现已补齐。
### 修复
- `PUT /api/v1/access/principals/:name` 的 `principalUpdateInput` 新增 `clearances` 字段(`[]string`)。
nil=不动;非空=全量替换(DELETE + INSERT),与 PUT /principals/:name/clearances 同义。
- `GET /api/v1/access/principals/:name` 响应新增 `clearances` 数组(保证非 nil,空集序列化为 `[]`)。
- `GET /api/v1/access/principals` 列表也回显 `clearances`,避免管理员看不到当前状态。
### 新增 MCP 工具
- `list_principals`:列出全部主体及其 clearance(之前 36 个工具没有读入口)。
- `get_principal`:按名取单个主体(含 description / has_api_key / clearances)。
- `set_principal_clearance`:全量替换主体 clearance(alias 接受 `markings` / `clearances`)。
### 不动的部分
- `seedAccessControlDefaults` 中 manager 默认 `[L0,L1,L2,L3,L4]` 已正确(CHANGELOG v1.2.0
「manager 不受影响」承诺依然成立)。
- `classificationCond` / `classAllowed` 中 `if authz.Principal == "manager" { return ... }` 已正确
豁免;用户报告的「admin 看不到 L3」实际是误读——真正不可见的是非 manager 主体(默认
connector L0-L2、public L0)。
### 验证
- 新增 3 个集成测试(issue7_clearance_config_test.go):
updatePrincipal clearances / MCP 端到端 / 旧专用端点回归,全绿。
**改动**:
- `PUT /access/principals/:name` 新增 `clearances []string`(nil=不动;非空=全量替换)。
- `GET /principals/:name` 与列表回显 `clearances`(保证非 nil)。
- MCP 新增 `list_principals` / `get_principal` / `set_principal_clearance` 三个工具。
## [1.3.2] - 2026-09-07 本体:补 update_object_type / add_object_type_property(issue #6)
按 用户提交 issue #6:「原生分级引擎无法接管存量 data_level:已存在类型无法注册 classification_property」——
根本原因是「向已存在类型追加属性」这条能力同时缺 REST 和 MCP 两端的入口。修复后即可接
管 587 个已打 data_level 的实例。
**影响**:本体管理工具集缺「向已存在类型追加属性」入口,导致 587 个 `data_level` 实例无法被分级引擎接管;现已补齐。
### 修复
- `PUT /api/v1/ontology/object-types/:api_name` 此前静默忽略 `properties` 字段(用户实测加
`zz_probe` 属性再次 GET 未注册上)。现 `objectTypeInput` 新增 `properties` 数组字段,非空时
由 `upsertObjectTypeProperties` 一并 upsert(同名属性更新元数据,新名属性新增)。语义与
`createObjectType` 内联 properties 一致。
- 同时为 `createObjectType` 也启用内联 `properties`(共用同一 upsert 辅助函数)。
**改动**:
- `PUT /object-types/:api_name` 静默忽略 `properties` 字段已修复,与 `createObjectType` 共用 `upsertObjectTypeProperties`(同名更新元数据,新名新增)。
- MCP 新增 `update_object_type` / `add_object_type_property` 工具。
### 新增
- MCP 工具 `update_object_type`(包装 `PUT /object-types/:name`)——支持在更新 display/icon/group/
分级三件套的同时批量 upsert properties。
- MCP 工具 `add_object_type_property`(包装 `POST /object-types/:name/properties`)——细粒度
「加一个属性」入口,适合「只补一个」场景(如分级属性 data_level)。
- `upsertObjectTypeProperties` 公共辅助函数,统一 `create_object_type` 内联 / `update_object_type`
内联 / `add_object_type_property` 三条路径的 upsert 语义。
### 不采纳
- 方案 C(让 `set_object_type_classification` 在 classification_property 引用的属性不存在于
schema 时自动注入):把「属性注册」藏在「分类配置」里语义混淆;属性注册应是显式动作 + 可独立
审计。
### 验证
- 新增 3 个集成测试(issue6_object_type_property_test.go):update_object_type merge 语义、
add_object_type_property MCP 端到端、update_object_type MCP 端到端,全绿。
**设计**:拒绝方案 C(让 `set_object_type_classification` 自动注入未注册属性)——属性注册应是显式动作,不应藏在分类配置里失去审计。
## [1.3.1] - 2026-09-07 访问控制:内置主体可设置自己的 API Key;密钥完全由 DB 管理
+12
View File
@@ -128,6 +128,18 @@ func (a *app) managerKeySet() bool {
return a.principalKeySet("manager")
}
// anyPrincipalKeySet 报告全库任意主体是否已配置非空 api_key(用于 connectorAuth 在
// 全库无密钥时放行、否则要求带 key 的判定)。修复 issue #8 v2:原 connectorKeySet 仅看
// connector 一个主体,现在需要看任意主体。
func (a *app) anyPrincipalKeySet() bool {
var n int
if err := a.pool.QueryRow(context.Background(),
"SELECT 1 FROM principals WHERE api_key IS NOT NULL AND api_key<>'' LIMIT 1").Scan(&n); err == nil {
return true
}
return false
}
// builtinKey 读取某内置主体当前存于 principals 表的 api_key(用于内部进程调用注入鉴权头)。
func (a *app) builtinKey(name string) string {
var k string
+108 -16
View File
@@ -17,6 +17,7 @@ import (
"encoding/json"
"log"
"strconv"
"strings"
"sync"
"time"
@@ -110,20 +111,24 @@ func (a *app) accessLogMiddleware() gin.HandlerFunc {
}
// 解析 principal
p := a.principalFromRequest(c)
// 提取目标 (type/pk)
typ := c.Param("type")
pk := c.Param("pk")
if typ == "" {
typ = c.Query("type")
}
if pk == "" {
pk = c.Query("pk")
// 提取目标 (type/pk)。三层来源:
// 1) handler 通过 c.Set("audit_target_pk", ...) 精确指定(create 类目标名在 body 里)
// 2) 按路由模板映射(targetFromRoute,修复 :name/:id 参数名导致 target 为空)
// 3) query 参数兜底(老行为)
typ, pk := targetFromRoute(c)
if v := c.GetString("audit_target_pk"); v != "" {
pk = v
}
// 决定(默认 allow;若 handler 已通过 c.Set("authz_decision", ...) 标记,则用它)
decision := c.GetString("authz_decision")
if decision == "" {
decision = "allow"
}
// 修复(2026-09-11):鉴权/业务层直接 401/403/404 的请求此前被记成 allow,
// 导致"拒绝"统计失真 —— 按最终响应状态码兜底标记。
if decision == "allow" && c.Writer.Status() >= 400 {
decision = "deny"
}
// 命中 grant(可选:handler 通过 c.Set("authz_grants", [...]) 写入)
var matchedGrants []int64
if v, ok := c.Get("authz_grants"); ok {
@@ -153,18 +158,77 @@ func (a *app) accessLogMiddleware() gin.HandlerFunc {
}
}
// targetFromRoute 按路由模板(c.FullPath())把请求映射到 (target_type, target_pk)。
// 此前只认 :type/:pk 两个参数名,而 /object-types/:name、/properties/:id 等路由的
// 参数名是 name/id,导致本体类型层操作的 target 长期为空,分项统计无从聚合。
// 约定:实例类路由(/objects/:type/:pk、/connector/object[s]/…)的 target_type
// 就是对象类型 api_name;元原语路由用固定类型名(object_type/link_type/...)。
func targetFromRoute(c *gin.Context) (string, string) {
// 实例路由::type(+:pk)参数天然就是目标
if t := c.Param("type"); t != "" {
return t, c.Param("pk")
}
// query 兜底(老行为保留)
if t := c.Query("type"); t != "" {
return t, c.Query("pk")
}
fp := c.FullPath()
if fp == "" {
return "", ""
}
name := c.Param("name")
id := c.Param("id")
switch {
case strings.Contains(fp, "/object-types/:name/properties"):
return "object_property", name // 具体属性名在 body,schemaAudit 会记全
case strings.Contains(fp, "/object-types/:name"):
return "object_type", name
case strings.Contains(fp, "/object-types"):
return "object_type", "" // create:名字在 body
case strings.Contains(fp, "/properties/:id"):
return "object_property", id
case strings.Contains(fp, "/link-types/:name/properties"):
return "link_property", name
case strings.Contains(fp, "/link-types/:name"):
return "link_type", name
case strings.Contains(fp, "/link-types"):
return "link_type", ""
case strings.Contains(fp, "/link-properties/:id"):
return "link_property", id
case strings.Contains(fp, "/action-types"):
return "action_type", ""
case strings.Contains(fp, "/function-types/:name"):
return "function_type", name
case strings.Contains(fp, "/function-types"):
return "function_type", ""
case strings.Contains(fp, "/interface-types/:name"):
return "interface_type", name
case strings.Contains(fp, "/interface-types"):
return "interface_type", ""
case strings.Contains(fp, "/materializations/:name"):
return "materialization", name
case strings.Contains(fp, "/backing-sources/:name"):
return "backing_source", name
case strings.Contains(fp, "/principals/:name"):
return "principal", name
case strings.Contains(fp, "/grants/:id"):
return "grant", id
case strings.Contains(fp, "/field-policies/:id"):
return "field_policy", id
}
return "", ""
}
func classifyAction(method, path string) string {
switch {
case contains(path, "/objects/") && method == "GET":
return "read"
case contains(path, "/objects") && (method == "POST" || method == "PUT"):
return "write"
case contains(path, "/objects/") && method == "DELETE":
return "delete"
case contains(path, "/connector/") && method == "GET":
return "read"
case contains(path, "/access/"):
return "manage"
case method == "GET":
return "read"
case method == "DELETE":
return "delete"
case method == "POST" || method == "PUT":
return "write"
default:
return method + " " + path
}
@@ -262,5 +326,33 @@ func (a *app) accessLogStats(c *gin.Context) {
c.JSON(200, gin.H{"stats": out})
}
// ---------- 保留策略 ----------
// startAccessLogRetention 定期清理过期 access_log,防止审计表无限膨胀。
// 默认保留 90 天(ACCESS_LOG_RETENTION_DAYS 覆盖,0 = 关闭清理)。
func startAccessLogRetention(p dbExec, days int) {
if days <= 0 {
log.Printf("[access_log] 保留策略已关闭(ACCESS_LOG_RETENTION_DAYS=0)")
return
}
go func() {
clean := func() {
tag, err := p.Exec(context.Background(),
`DELETE FROM access_log WHERE created_at < now() - make_interval(days => $1)`, days)
if err != nil {
log.Printf("[access_log] 过期清理失败: %v", err)
} else if tag.RowsAffected() > 0 {
log.Printf("[access_log] 清理过期审计日志 %d 行(保留 %d 天)", tag.RowsAffected(), days)
}
}
clean() // 启动时清一次
t := time.NewTicker(24 * time.Hour)
defer t.Stop()
for range t.C {
clean()
}
}()
}
// strconv_Atoi 占位(已用标准库,保留符号避免引用残留)
var _ = strconv.Atoi
+8
View File
@@ -614,6 +614,14 @@ func (a *app) setObjectTypeClassification(c *gin.Context) {
c.JSON(400, gin.H{"error": "body 必须是合法 JSON: " + err.Error()})
return
}
// before 快照(审计用)
before := a.objectTypeSnapshot(c, name)
// 分级配置也是 schema 变更,统一走 ontology_audit_log(仅在成功响应时记录)
defer func() {
if c.Writer.Status() < 400 {
a.schemaAudit(c, "object_type_classification", "object_type", name, map[string]any{"before": before, "after": in})
}
}()
// 关掉分级(property=空)允许 levels=[] 与 default=""
if in.Property == "" {
// property=空直接落库:levels 与 default 都以「空」处理(不会去校验词汇)
+2
View File
@@ -17,6 +17,7 @@ type Config struct {
AllowCORS bool
SeedOnStart bool // 首次启动若本体为空则灌入极简占位种子
ArchiveDir string // 知识文件根目录(archive),文件管理功能使用
AccessLogRetentionDays int // access_log 保留天数(0=不清理),默认 90
}
func loadConfig() *Config {
@@ -30,6 +31,7 @@ func loadConfig() *Config {
AllowCORS: getEnvBool("ALLOW_CORS", true),
SeedOnStart: getEnvBool("SEED_ON_START", true),
ArchiveDir: getEnv("ARCHIVE_DIR", "archive"),
AccessLogRetentionDays: getEnvInt("ACCESS_LOG_RETENTION_DAYS", 90),
}
return c
}
+2
View File
@@ -327,6 +327,8 @@ CREATE TABLE IF NOT EXISTS ontology_audit_log (
);
CREATE INDEX IF NOT EXISTS idx_audit_log_created ON ontology_audit_log(created_at);
CREATE INDEX IF NOT EXISTS idx_audit_log_actor ON ontology_audit_log(actor);
-- 兼容存量库(2026-09-11):schema 审计按 target_pk 精确落库
ALTER TABLE ontology_audit_log ADD COLUMN IF NOT EXISTS target_pk TEXT DEFAULT '';
-- 兼容存量库:补 P1-4 Interface 共享 properties + 多态 (2026-08-24)
ALTER TABLE interface_types ADD COLUMN IF NOT EXISTS shared_properties JSONB DEFAULT '[]'::jsonb;
+17 -7
View File
@@ -214,14 +214,24 @@ func (a *app) updatePrincipal(c *gin.Context) {
a.InvalidateAuthzCache(name)
// 回读,让前端能立即核对(同时验证上面 writes)
resp := gin.H{"ok": true, "name": name}
if finalKey != "" {
resp["api_key"] = finalKey
resp["api_key_hint"] = maskAPIKey(finalKey)
resp["has_api_key"] = true
} else if in.ClearAPIKey {
resp["has_api_key"] = false
keyTouched := in.ClearAPIKey || in.GenerateAPIKey || (in.APIKey != nil && *in.APIKey != "")
if keyTouched {
// 这次请求确实动了 api_key,按结果回显
if finalKey != "" {
resp["api_key"] = finalKey
resp["api_key_hint"] = maskAPIKey(finalKey)
resp["has_api_key"] = true
} else if in.ClearAPIKey {
resp["has_api_key"] = false
} else {
resp["has_api_key"] = finalKey != ""
}
} else {
resp["has_api_key"] = finalKey != ""
// 未提供 api_key 相关字段:回显 DB 真实状态,避免误导。
// 修复 issue #8 附注:之前此处错误地把 "未传 api_key" 当作 "key 不存在"。
var cur string
_ = a.pool.QueryRow(c, `SELECT COALESCE(api_key,'') FROM principals WHERE name=$1`, name).Scan(&cur)
resp["has_api_key"] = cur != ""
}
if in.Clearances != nil {
resp["clearances"] = *in.Clearances
+479
View File
@@ -0,0 +1,479 @@
package main
// 使用分析(2026-09-11)
//
// 基于既有数据现算,不建新表:
// - access_log → 请求量 / 浏览(read) / 修改(write,delete) / 活跃用户 / 来源分布
// - object_changes → 实例级增删改(含字段 diff 的量)
// - ontology_audit_log → schema 层变更(object_type/link_type/property/...)
// - grants + principals → 共享关系矩阵 + 关联使用量
//
// 时间口径:days 参数(默认 30,1..365);按天分组用 Asia/Shanghai 时区。
import (
"encoding/json"
"net/http"
"sort"
"strconv"
"time"
"github.com/gin-gonic/gin"
)
const tzExpr = "AT TIME ZONE 'Asia/Shanghai'"
func daysParam(c *gin.Context) int {
d, err := strconv.Atoi(c.Query("days"))
if err != nil || d <= 0 || d > 365 {
return 30
}
return d
}
// ---------- 总体 ----------
// analyticsOverview 总体:请求量 / 读写分布 / 活跃用户 / 来源分布 / 按天趋势 / 最近 schema 变更
// GET /api/v1/analytics/overview?days=30
func (a *app) analyticsOverview(c *gin.Context) {
days := daysParam(c)
since := time.Now().AddDate(0, 0, -days)
var total, reads, writes, deletes, denies, mcpCnt, connCnt, kmCnt, users int64
err := a.pool.QueryRow(c, `
SELECT count(*),
count(*) FILTER (WHERE action='read'),
count(*) FILTER (WHERE action='write'),
count(*) FILTER (WHERE action='delete'),
count(*) FILTER (WHERE decision<>'allow'),
count(*) FILTER (WHERE path LIKE '/api/v1/mcp%'),
count(*) FILTER (WHERE path LIKE '/api/v1/connector/%'),
count(*) FILTER (WHERE path LIKE '/api/v1/km/%'),
count(DISTINCT principal) FILTER (WHERE principal <> '')
FROM access_log WHERE created_at >= $1`, since).Scan(
&total, &reads, &writes, &deletes, &denies, &mcpCnt, &connCnt, &kmCnt, &users)
if err != nil {
c.JSON(500, gin.H{"error": err.Error()})
return
}
// 按天趋势
type dayRow struct {
Day string `json:"day"`
Requests int64 `json:"requests"`
Reads int64 `json:"reads"`
Writes int64 `json:"writes"`
Users int64 `json:"users"`
}
dayRows, err := a.pool.Query(c, `
SELECT to_char(created_at `+tzExpr+`, 'YYYY-MM-DD') AS day,
count(*) AS requests,
count(*) FILTER (WHERE action='read') AS reads,
count(*) FILTER (WHERE action IN ('write','delete')) AS writes,
count(DISTINCT principal) FILTER (WHERE principal<>'') AS users
FROM access_log WHERE created_at >= $1
GROUP BY day ORDER BY day`, since)
if err != nil {
c.JSON(500, gin.H{"error": err.Error()})
return
}
defer dayRows.Close()
byDay := []dayRow{}
for dayRows.Next() {
var r dayRow
if dayRows.Scan(&r.Day, &r.Requests, &r.Reads, &r.Writes, &r.Users) == nil {
byDay = append(byDay, r)
}
}
// 热门目标(读)
type topRow struct {
TargetType string `json:"target_type"`
TargetPK string `json:"target_pk"`
Count int64 `json:"count"`
}
topRows, err := a.pool.Query(c, `
SELECT target_type, target_pk, count(*) AS c
FROM access_log
WHERE created_at >= $1 AND method='GET' AND target_type <> ''
GROUP BY 1,2 ORDER BY c DESC LIMIT 10`, since)
if err != nil {
c.JSON(500, gin.H{"error": err.Error()})
return
}
defer topRows.Close()
topTargets := []topRow{}
for topRows.Next() {
var r topRow
if topRows.Scan(&r.TargetType, &r.TargetPK, &r.Count) == nil {
topTargets = append(topTargets, r)
}
}
// 最近 schema 变更(本体编辑记录)
type auditRow struct {
CreatedAt string `json:"created_at"`
Actor string `json:"actor"`
Action string `json:"action"`
TargetType string `json:"target_type"`
TargetPK string `json:"target_pk"`
Details map[string]any `json:"details"`
}
auditRows, err := a.pool.Query(c, `
SELECT to_char(created_at `+tzExpr+`, 'YYYY-MM-DD HH24:MI'), actor, action, target_type, target_pk, details
FROM ontology_audit_log ORDER BY id DESC LIMIT 15`)
if err != nil {
c.JSON(500, gin.H{"error": err.Error()})
return
}
defer auditRows.Close()
recentSchema := []auditRow{}
for auditRows.Next() {
var r auditRow
var details []byte
if auditRows.Scan(&r.CreatedAt, &r.Actor, &r.Action, &r.TargetType, &r.TargetPK, &details) == nil {
_ = json.Unmarshal(details, &r.Details)
recentSchema = append(recentSchema, r)
}
}
c.JSON(http.StatusOK, gin.H{
"days": days,
"total": total,
"reads": reads,
"writes": writes,
"deletes": deletes,
"denies": denies,
"mcp_requests": mcpCnt,
"conn_requests": connCnt,
"km_requests": kmCnt,
"active_users": users,
"by_day": byDay,
"top_targets": topTargets,
"recent_schema": recentSchema,
})
}
// ---------- 分项(按对象类型) ----------
// analyticsTypes 每个对象类型:本体定义浏览量 / 实例浏览量 / 实例修改量 / 最近时间
// GET /api/v1/analytics/types?days=30
func (a *app) analyticsTypes(c *gin.Context) {
days := daysParam(c)
since := time.Now().AddDate(0, 0, -days)
type typeStat struct {
Name string `json:"name"`
DisplayName string `json:"display_name"`
Group string `json:"group"`
Instances int64 `json:"instances"`
OntViews int64 `json:"ontology_views"` // 本体定义/编辑页浏览
InstReads int64 `json:"instance_reads"` // 实例浏览(管理台 + 连接器 + MCP 读)
InstWrites int64 `json:"instance_writes"` // 实例增删改(object_changes)
SchemaChanges int64 `json:"schema_changes"` // 类型/属性定义变更(ontology_audit_log)
LastRead string `json:"last_read"`
LastWrite string `json:"last_write"`
}
stats := map[string]*typeStat{}
// 1) 全部对象类型打底
rows, err := a.pool.Query(c, `
SELECT ot.api_name, ot.display_name, COALESCE(ot.group_name,''),
(SELECT count(*) FROM objects o WHERE o.object_type_id = ot.id)
FROM object_types ot`)
if err != nil {
c.JSON(500, gin.H{"error": err.Error()})
return
}
for rows.Next() {
var n, dn, g string
var cnt int64
if rows.Scan(&n, &dn, &g, &cnt) == nil {
stats[n] = &typeStat{Name: n, DisplayName: dn, Group: g, Instances: cnt}
}
}
rows.Close()
get := func(n string) *typeStat {
s, ok := stats[n]
if !ok {
s = &typeStat{Name: n}
stats[n] = s
}
return s
}
// 2) 本体定义浏览(target_type='object_type' 的 GET)
rows, err = a.pool.Query(c, `
SELECT target_pk, count(*), COALESCE(to_char(max(created_at) `+tzExpr+`, 'YYYY-MM-DD HH24:MI'),'')
FROM access_log
WHERE created_at >= $1 AND method='GET' AND target_type='object_type' AND target_pk <> ''
GROUP BY 1`, since)
if err != nil {
c.JSON(500, gin.H{"error": err.Error()})
return
}
for rows.Next() {
var pk, last string
var cnt int64
if rows.Scan(&pk, &cnt, &last) == nil {
s := get(pk)
s.OntViews = cnt
s.LastRead = last
}
}
rows.Close()
// 3) 实例浏览(/objects/:type/... 与 /connector/object[s]/... 的 GET)
rows, err = a.pool.Query(c, `
SELECT target_type, count(*), COALESCE(to_char(max(created_at) `+tzExpr+`, 'YYYY-MM-DD HH24:MI'),'')
FROM access_log
WHERE created_at >= $1 AND method='GET' AND target_type <> '' AND target_type <> 'object_type'
AND (path LIKE '/api/v1/objects/%' OR path LIKE '/api/v1/connector/object%' OR path='/api/v1/mcp')
GROUP BY 1`, since)
if err != nil {
c.JSON(500, gin.H{"error": err.Error()})
return
}
for rows.Next() {
var tn, last string
var cnt int64
if rows.Scan(&tn, &cnt, &last) == nil {
s := get(tn)
s.InstReads = cnt
if last > s.LastRead {
s.LastRead = last
}
}
}
rows.Close()
// 4) 实例修改(object_changes:create/update/delete/restore)
rows, err = a.pool.Query(c, `
SELECT object_type, count(*), COALESCE(to_char(max(created_at) `+tzExpr+`, 'YYYY-MM-DD HH24:MI'),'')
FROM object_changes WHERE created_at >= $1 GROUP BY 1`, since)
if err != nil {
c.JSON(500, gin.H{"error": err.Error()})
return
}
for rows.Next() {
var tn, last string
var cnt int64
if rows.Scan(&tn, &cnt, &last) == nil {
s := get(tn)
s.InstWrites = cnt
s.LastWrite = last
}
}
rows.Close()
// 5) schema 变更(ontology_audit_log 中 object_type / object_property 按 target_pk 前缀归属类型)
rows, err = a.pool.Query(c, `
SELECT target_type, target_pk, count(*)
FROM ontology_audit_log
WHERE created_at >= $1 AND target_type IN ('object_type','object_property')
GROUP BY 1,2`, since)
if err != nil {
c.JSON(500, gin.H{"error": err.Error()})
return
}
for rows.Next() {
var tt, tp string
var cnt int64
if rows.Scan(&tt, &tp, &cnt) == nil {
name := tp
// object_property 的 target_pk 是 "类型.属性名" 或 "id:N"(历史记录),取前缀归属
if tt == "object_property" {
if i := lastIndexByte(name, '.'); i > 0 {
name = name[:i]
} else {
continue // id:N 无法归属到类型,跳过
}
}
get(name).SchemaChanges += cnt
}
}
rows.Close()
out := make([]typeStat, 0, len(stats))
for _, s := range stats {
out = append(out, *s)
}
// 按热度排序:实例读 > 定义浏览 > 实例写 > 实例数
sort.Slice(out, func(i, j int) bool {
si, sj := out[i], out[j]
ki, kj := si.InstReads+si.OntViews*2+si.InstWrites*3, sj.InstReads+sj.OntViews*2+sj.InstWrites*3
if ki != kj {
return ki > kj
}
return si.Instances > sj.Instances
})
c.JSON(http.StatusOK, gin.H{"days": days, "types": out})
}
func lastIndexByte(s string, b byte) int {
for i := len(s) - 1; i >= 0; i-- {
if s[i] == b {
return i
}
}
return -1
}
// ---------- 用户活跃 ----------
// analyticsUsers 每个主体:请求量 / 读 / 写 / 删 / 拒绝 / 触达目标数 / 最近活跃
// GET /api/v1/analytics/users?days=30
func (a *app) analyticsUsers(c *gin.Context) {
days := daysParam(c)
since := time.Now().AddDate(0, 0, -days)
type userStat struct {
Principal string `json:"principal"`
Requests int64 `json:"requests"`
Reads int64 `json:"reads"`
Writes int64 `json:"writes"`
Deletes int64 `json:"deletes"`
Denies int64 `json:"denies"`
Targets int64 `json:"targets"`
LastActive string `json:"last_active"`
Active bool `json:"active"`
}
stats := map[string]*userStat{}
rows, err := a.pool.Query(c, `
SELECT principal, count(*),
count(*) FILTER (WHERE action='read'),
count(*) FILTER (WHERE action='write'),
count(*) FILTER (WHERE action='delete'),
count(*) FILTER (WHERE decision<>'allow'),
count(DISTINCT (target_type || '/' || target_pk)) FILTER (WHERE target_type<>''),
COALESCE(to_char(max(created_at) `+tzExpr+`, 'YYYY-MM-DD HH24:MI'),'')
FROM access_log
WHERE created_at >= $1 AND principal <> ''
GROUP BY principal ORDER BY count(*) DESC`, since)
if err != nil {
c.JSON(500, gin.H{"error": err.Error()})
return
}
for rows.Next() {
var u userStat
if rows.Scan(&u.Principal, &u.Requests, &u.Reads, &u.Writes, &u.Deletes, &u.Denies, &u.Targets, &u.LastActive) == nil {
u.Active = true
stats[u.Principal] = &u
}
}
rows.Close()
// principals 表打底:窗口期内没动静的主体标 active=false
rows, err = a.pool.Query(c, `SELECT name, COALESCE(description,'') FROM principals ORDER BY name`)
if err != nil {
c.JSON(500, gin.H{"error": err.Error()})
return
}
type pInfo struct {
Desc string `json:"description"`
}
principals := map[string]pInfo{}
for rows.Next() {
var n, d string
if rows.Scan(&n, &d) == nil {
principals[n] = pInfo{Desc: d}
if _, ok := stats[n]; !ok {
stats[n] = &userStat{Principal: n}
}
}
}
rows.Close()
out := make([]userStat, 0, len(stats))
for _, s := range stats {
out = append(out, *s)
}
sort.Slice(out, func(i, j int) bool { return out[i].Requests > out[j].Requests })
c.JSON(http.StatusOK, gin.H{"days": days, "users": out, "principals": principals})
}
// ---------- 共享 ----------
// analyticsSharing 授权(grant)矩阵 + 每条授权在窗口期内的实际使用量
// GET /api/v1/analytics/sharing?days=30
func (a *app) analyticsSharing(c *gin.Context) {
days := daysParam(c)
since := time.Now().AddDate(0, 0, -days)
type grantRow struct {
ID int64 `json:"id"`
Principal string `json:"principal"`
Action string `json:"action"`
ScopeType string `json:"scope_type"`
ScopePK string `json:"scope_pk"`
Effect string `json:"effect"`
Used int64 `json:"used"` // 窗口期内该主体落在该 scope 范围内的请求数
}
rows, err := a.pool.Query(c, `
SELECT g.id, g.principal, g.action, g.scope_type, g.scope_pk, g.effect,
(SELECT count(*) FROM access_log al
WHERE al.created_at >= $1 AND al.principal = g.principal
AND (g.scope_type = '*' OR al.target_type = g.scope_type)
AND (g.scope_pk = '*' OR al.target_pk = g.scope_pk)) AS used
FROM grants g ORDER BY g.principal, g.id`, since)
if err != nil {
c.JSON(500, gin.H{"error": err.Error()})
return
}
defer rows.Close()
grants := []grantRow{}
sharedPrincipals := map[string]bool{}
for rows.Next() {
var r grantRow
if rows.Scan(&r.ID, &r.Principal, &r.Action, &r.ScopeType, &r.ScopePK, &r.Effect, &r.Used) == nil {
grants = append(grants, r)
sharedPrincipals[r.Principal] = true
}
}
// 每个被共享主体的使用总量(读/写)
type pUsage struct {
Principal string `json:"principal"`
Grants int64 `json:"grants"`
Requests int64 `json:"requests"`
Reads int64 `json:"reads"`
Writes int64 `json:"writes"`
}
usageRows, err := a.pool.Query(c, `
SELECT al.principal, count(*),
count(*) FILTER (WHERE al.action='read'),
count(*) FILTER (WHERE al.action IN ('write','delete'))
FROM access_log al
WHERE al.created_at >= $1 AND al.principal = ANY($2::text[])
GROUP BY al.principal ORDER BY count(*) DESC`, since, mapKeys(sharedPrincipals))
if err != nil {
c.JSON(500, gin.H{"error": err.Error()})
return
}
defer usageRows.Close()
usage := []pUsage{}
for usageRows.Next() {
var u pUsage
if usageRows.Scan(&u.Principal, &u.Requests, &u.Reads, &u.Writes) == nil {
usage = append(usage, u)
}
}
for i := range usage {
for _, g := range grants {
if g.Principal == usage[i].Principal {
usage[i].Grants++
}
}
}
c.JSON(http.StatusOK, gin.H{"days": days, "grants": grants, "usage": usage})
}
func mapKeys(m map[string]bool) []string {
out := make([]string, 0, len(m))
for k := range m {
out = append(out, k)
}
return out
}
+27 -9
View File
@@ -665,7 +665,7 @@ func (a *app) mcpDispatchTool(c *gin.Context, name string, args map[string]inter
return string(b), false, false
case "get_object_types":
return a.callConn("GET", "/api/v1/connector/object-types", nil), false, false
return a.callConn(c, "GET", "/api/v1/connector/object-types", nil), false, false
case "get_objects_by_type":
typ, _ := args["type"].(string)
@@ -677,12 +677,12 @@ func (a *app) mcpDispatchTool(c *gin.Context, name string, args map[string]inter
if v, ok := args["offset"].(float64); ok && v > 0 {
qs += "&offset=" + strconv.Itoa(int(v))
}
return a.callConn("GET", "/api/v1/connector/objects/"+url.PathEscape(typ)+qs, nil), false, false
return a.callConn(c, "GET", "/api/v1/connector/objects/"+url.PathEscape(typ)+qs, nil), false, false
case "get_object":
typ, _ := args["type"].(string)
pk, _ := args["pk"].(string)
return a.callConn("GET", "/api/v1/connector/object/"+url.PathEscape(typ)+"/"+url.PathEscape(pk), nil), false, false
return a.callConn(c, "GET", "/api/v1/connector/object/"+url.PathEscape(typ)+"/"+url.PathEscape(pk), nil), false, false
case "search_ontology":
q, _ := args["q"].(string)
@@ -699,7 +699,7 @@ func (a *app) mcpDispatchTool(c *gin.Context, name string, args map[string]inter
if field != "" {
u += "&field=" + url.QueryEscape(field)
}
return a.callConn("GET", u, nil), false, false
return a.callConn(c, "GET", u, nil), false, false
case "km_list_tree":
t, _ := a.mcpCall("GET", "/api/v1/km/tree", nil, principal)
@@ -757,7 +757,7 @@ func (a *app) mcpDispatchTool(c *gin.Context, name string, args map[string]inter
if typ != "" {
u += "?type=" + url.QueryEscape(typ)
}
return a.callConn("GET", u, nil), false, false
return a.callConn(c, "GET", u, nil), false, false
case "query_related":
typ, _ := args["type"].(string)
@@ -768,7 +768,7 @@ func (a *app) mcpDispatchTool(c *gin.Context, name string, args map[string]inter
}
filters, _ := args["filters"].(map[string]interface{})
body, _ := json.Marshal(queryInput{Type: typ, Filters: filters, Expand: expand, Limit: limit})
return a.callConn("POST", "/api/v1/connector/query", body), false, false
return a.callConn(c, "POST", "/api/v1/connector/query", body), false, false
case "whoami":
// principal / canWrite 已在函数顶部解析
@@ -1116,17 +1116,35 @@ func (a *app) mcpCall(method, path string, body []byte, principal string) (strin
}
// callConn 进程内把请求路由到连接器 handler,复用现有只读逻辑。
func (a *app) callConn(method, path string, body []byte) string {
// 修复 issue #8(v2,按用户「每个主体都有 mcp 访问 key,应该是各自主体身份」反馈):
//
// 透传调用方真实身份(X-API-Key 或 session cookie)给内层请求,
// 让 principalFromRequest 自然解析到对应主体(manager / connector / analyst / ...),
// 读路径的 visibility / classification filter 即按真实身份工作。
//
// 之前 v1 方案(注入 connector key + 手动 X-Principal)本质是「模拟身份」,
// 绕开了主体解析链——仍以 connector 权限过 connectorAuth,再用 X-Principal 覆盖身份,
// 同一份逻辑在两套机制间切来切去。透传更简洁,且与「每个主体各有 key」的设计一致。
//
// connectorAuth 同步放宽:接受任何内置/非内置主体的 key(详见 main.go 注释)。
// principal 参数保留:用于日志/tracing,不参与 auth。
func (a *app) callConn(c *gin.Context, method, path string, body []byte) string {
var reader io.Reader
if body != nil {
reader = bytes.NewReader(body)
}
req := httptest.NewRequest(method, path, reader)
req.Header.Set("Content-Type", "application/json")
// 内部调用连接器 handler:注入 connector 主体的 api_key 以通过 connectorAuth(密钥统一存于 principals 表)。
if k := a.builtinKey("connector"); k != "" {
// 透传调用方真实鉴权:让 principalFromRequest 自然解析到对应主体。
if k := c.GetHeader("X-API-Key"); k != "" {
req.Header.Set("X-API-Key", k)
}
if k := c.Query("key"); k != "" && c.GetHeader("X-API-Key") == "" {
req.Header.Set("X-API-Key", k)
}
if tok, err := c.Cookie(SessionCookieName); err == nil && tok != "" {
req.AddCookie(&http.Cookie{Name: SessionCookieName, Value: tok})
}
w := httptest.NewRecorder()
a.engine.ServeHTTP(w, req)
return w.Body.String()
+55
View File
@@ -110,6 +110,9 @@ func (a *app) createObjectType(c *gin.Context) {
return
}
}
// schema 审计(2026-09-11):create 记录输入快照
c.Set("audit_target_pk", in.APIName)
a.schemaAudit(c, "object_type_create", "object_type", in.APIName, map[string]any{"after": in})
c.JSON(201, gin.H{"id": id, "api_name": in.APIName})
}
@@ -147,6 +150,8 @@ func (a *app) updateObjectType(c *gin.Context) {
return
}
defer invalidateClassCache()
// before 快照(更新前,审计用)
before := a.objectTypeSnapshot(c, name)
// 分级三件套允许显式置空:传空串即关闭(property)/清空(levels,default)
lvJSON := mustJSON(in.ClassificationLevels)
clearProp := in.ClassificationProperty != ""
@@ -188,6 +193,9 @@ func (a *app) updateObjectType(c *gin.Context) {
return
}
}
// schema 审计(2026-09-11):before/after
c.Set("audit_target_pk", name)
a.schemaAudit(c, "object_type_update", "object_type", name, map[string]any{"before": before, "after": in})
c.JSON(200, gin.H{"ok": true})
}
@@ -238,6 +246,8 @@ func (a *app) upsertObjectTypeProperties(c *gin.Context, oid int64, props []prop
func (a *app) deleteObjectType(c *gin.Context) {
name := c.Param("name")
// before 快照(删除前,审计 + 误删可查)
before := a.objectTypeSnapshot(c, name)
tag, err := a.pool.Exec(c, `DELETE FROM object_types WHERE api_name=$1`, name)
if err != nil {
c.JSON(500, gin.H{"error": err.Error()})
@@ -247,6 +257,7 @@ func (a *app) deleteObjectType(c *gin.Context) {
c.JSON(404, gin.H{"error": "对象类型不存在"})
return
}
a.schemaAudit(c, "object_type_delete", "object_type", name, map[string]any{"before": before})
c.JSON(200, gin.H{"ok": true})
}
@@ -343,6 +354,7 @@ func (a *app) addProperty(c *gin.Context) {
return
}
invalidateClassCache()
a.schemaAudit(c, "property_add", "object_property", name+"."+in.APIName, map[string]any{"after": in})
c.JSON(201, gin.H{"ok": true})
}
@@ -353,6 +365,8 @@ func (a *app) updateProperty(c *gin.Context) {
c.JSON(400, gin.H{"error": err.Error()})
return
}
// before 快照(更新前,审计用)
before := a.propertySnapshot(c, id)
enum := "[]"
if len(in.EnumValues) > 0 {
enum = mustJSON(in.EnumValues)
@@ -380,11 +394,21 @@ func (a *app) updateProperty(c *gin.Context) {
return
}
invalidateClassCache()
// schema 审计(2026-09-11):target_pk 用 类型.属性名(before 里拿得到时),否则退回 id
pk := fmt.Sprintf("id:%d", id)
if before != nil {
if ot, ok := before["object_type"].(string); ok && ot != "" {
pk = ot + "." + before["api_name"].(string)
}
}
a.schemaAudit(c, "property_update", "object_property", pk, map[string]any{"before": before, "after": in})
c.JSON(200, gin.H{"ok": true})
}
func (a *app) deleteProperty(c *gin.Context) {
id, _ := strconv.ParseInt(c.Param("id"), 10, 64)
// before 快照(删除前,审计 + 误删可查)
before := a.propertySnapshot(c, id)
tag, err := a.pool.Exec(c, `DELETE FROM properties WHERE id=$1`, id)
if err != nil {
c.JSON(500, gin.H{"error": err.Error()})
@@ -395,6 +419,13 @@ func (a *app) deleteProperty(c *gin.Context) {
return
}
invalidateClassCache()
pk := fmt.Sprintf("id:%d", id)
if before != nil {
if ot, ok := before["object_type"].(string); ok && ot != "" {
pk = ot + "." + before["api_name"].(string)
}
}
a.schemaAudit(c, "property_delete", "object_property", pk, map[string]any{"before": before})
c.JSON(200, gin.H{"ok": true})
}
@@ -448,6 +479,9 @@ func (a *app) createLinkType(c *gin.Context) {
if in.Cardinality == "" {
in.Cardinality = "many_to_many"
}
// upsert 语义:区分 create / update 供审计归类
var existed int
isUpdate := a.pool.QueryRow(c, `SELECT 1 FROM link_types WHERE api_name=$1`, in.APIName).Scan(&existed) == nil
_, err := a.pool.Exec(c,
`INSERT INTO link_types(api_name,display_name,source_type,target_type,cardinality,description,
directional,source_property,target_property)
@@ -466,11 +500,19 @@ func (a *app) createLinkType(c *gin.Context) {
c.JSON(500, gin.H{"error": err.Error()})
return
}
c.Set("audit_target_pk", in.APIName)
action := "link_type_create"
if isUpdate {
action = "link_type_update"
}
a.schemaAudit(c, action, "link_type", in.APIName, map[string]any{"after": in})
c.JSON(201, gin.H{"ok": true})
}
func (a *app) deleteLinkType(c *gin.Context) {
name := c.Param("name")
// before 快照(删除前,审计 + 误删可查)
before := a.linkTypeSnapshot(c, name)
tag, err := a.pool.Exec(c, `DELETE FROM link_types WHERE api_name=$1`, name)
if err != nil {
c.JSON(500, gin.H{"error": err.Error()})
@@ -480,6 +522,7 @@ func (a *app) deleteLinkType(c *gin.Context) {
c.JSON(404, gin.H{"error": "链接类型不存在"})
return
}
a.schemaAudit(c, "link_type_delete", "link_type", name, map[string]any{"before": before})
c.JSON(200, gin.H{"ok": true})
}
@@ -565,11 +608,14 @@ func (a *app) addLinkProperty(c *gin.Context) {
c.JSON(500, gin.H{"error": err.Error()})
return
}
a.schemaAudit(c, "link_property_add", "link_property", name+"."+in.APIName, map[string]any{"after": in})
c.JSON(201, gin.H{"ok": true})
}
func (a *app) deleteLinkProperty(c *gin.Context) {
id, _ := strconv.ParseInt(c.Param("id"), 10, 64)
// before 快照(删除前,审计 + 误删可查)
before := a.linkPropertySnapshot(c, id)
tag, err := a.pool.Exec(c, `DELETE FROM link_properties WHERE id=$1`, id)
if err != nil {
c.JSON(500, gin.H{"error": err.Error()})
@@ -579,6 +625,13 @@ func (a *app) deleteLinkProperty(c *gin.Context) {
c.JSON(404, gin.H{"error": "链接属性不存在"})
return
}
pk := fmt.Sprintf("id:%d", id)
if before != nil {
if lt, ok := before["link_type"].(string); ok && lt != "" {
pk = lt + "." + before["api_name"].(string)
}
}
a.schemaAudit(c, "link_property_delete", "link_property", pk, map[string]any{"before": before})
c.JSON(200, gin.H{"ok": true})
}
@@ -692,6 +745,8 @@ func (a *app) createActionType(c *gin.Context) {
c.JSON(500, gin.H{"error": err.Error()})
return
}
c.Set("audit_target_pk", in.APIName)
a.schemaAudit(c, "action_type_upsert", "action_type", in.APIName, map[string]any{"after": in})
c.JSON(201, gin.H{"ok": true})
}
+328
View File
@@ -0,0 +1,328 @@
//go:build integration
package main
import (
"context"
"strings"
"testing"
)
func lenAny(v interface{}) int {
if v == nil {
return 0
}
if sl, ok := v.([]interface{}); ok {
return len(sl)
}
return -1
}
// extractCount 从 MCP 响应里取 count 字段(MCP 工具结果以 JSON 字符串放在 content[0].text)。
// 返回 -1 表示解析失败。
func extractCount(t *testing.T, body map[string]interface{}) int {
t.Helper()
result, ok := body["result"].(map[string]interface{})
if !ok {
return -1
}
content, ok := result["content"].([]interface{})
if !ok || len(content) == 0 {
return -1
}
first, ok := content[0].(map[string]interface{})
if !ok {
return -1
}
text, ok := first["text"].(string)
if !ok {
return -1
}
// 在 text 里找 "count":N
needle := `"count":`
i := strings.Index(text, needle)
if i < 0 {
return -1
}
rest := text[i+len(needle):]
// 跳过空白
for len(rest) > 0 && (rest[0] == ' ' || rest[0] == '\t') {
rest = rest[1:]
}
// 读数字
end := 0
for end < len(rest) && rest[end] >= '0' && rest[end] <= '9' {
end++
}
if end == 0 {
return -1
}
n, err := strconvAtoi(rest[:end])
if err != nil {
return -1
}
return n
}
// strconvAtoi 局部 int 解析(避免 import strconv)
func strconvAtoi(s string) (int, error) {
n := 0
if s == "" {
return 0, errEmpty
}
for _, c := range s {
if c < '0' || c > '9' {
return 0, errNotDigit
}
n = n*10 + int(c-'0')
}
return n, nil
}
var (
errEmpty = simpleErr("empty")
errNotDigit = simpleErr("not digit")
)
type simpleErr string
func (e simpleErr) Error() string { return string(e) }
// seedConnectorForTest 在测试 DB 里塞内置 connector 主体(api_key 已知)。
// setupTestEnv 不调用 seedAccessControlDefaults(避免污染共享测试库),所以每个
// 走 callConn 路径的测试自己负责准备。
func seedConnectorForTest(t *testing.T) string {
t.Helper()
pool, err := initDB(context.Background(), testDSN())
if err != nil {
t.Skipf("无法连接测试 PG: %v", err)
}
defer pool.Close()
const connKey = "test-connector-key-do-not-use-in-prod"
const mgrKey = "test-manager-key-do-not-use-in-prod"
const anaKey = "test-analyst-key-do-not-use-in-prod"
_, _ = pool.Exec(context.Background(),
`INSERT INTO principals(name,description,is_builtin,api_key) VALUES('connector','test connector',true,$1)
ON CONFLICT(name) DO UPDATE SET api_key=EXCLUDED.api_key`,
connKey)
_, _ = pool.Exec(context.Background(),
`INSERT INTO principals(name,description,is_builtin,api_key) VALUES('manager','test manager',true,$1)
ON CONFLICT(name) DO UPDATE SET api_key=EXCLUDED.api_key`,
mgrKey)
_, _ = pool.Exec(context.Background(),
`INSERT INTO principals(name,description,is_builtin,api_key) VALUES('analyst','test analyst',true,$1)
ON CONFLICT(name) DO UPDATE SET api_key=EXCLUDED.api_key`,
anaKey)
// 注入 clearance:connector L0+L1(与生产 seed 一致);manager L0..L4(豁免前的真实
// clearance 仍写入 DB,classificationCond 对 manager 走 return TRUE 所以不影响;
// analyst 仅 L0(最受限)
// 先 DELETE 再 INSERT,避免上次测试残留的 clearance 留下误配置
_, _ = pool.Exec(context.Background(),
`DELETE FROM principal_clearances WHERE principal IN ('connector','manager','analyst')`)
_, _ = pool.Exec(context.Background(),
`INSERT INTO principal_clearances(principal,marking)
VALUES('connector','L0'),('connector','L1'),
('manager','L0'),('manager','L1'),('manager','L2'),('manager','L3'),('manager','L4'),
('analyst','L0')`)
invalidateClassCache()
authzCache.Range(func(k, _ any) bool { authzCache.Delete(k); return true })
return connKey
}
// TestIntegration_MCPRead_RespectsPrincipal 修复 issue #8:
// 之前 callConn 硬编码 connector 的 api_key,导致所有 MCP 读工具
// (get_objects_by_type / get_object / query_related / search_ontology /
// get_object_types / get_facets)一律以 connector 主体执行——manager 走
// MCP 也只能看到 connector clearance(L0-L2)下的数据,违反 v1.2.0 「manager 不受影响」。
//
// 新行为:callConn 接受 principal 参数,内层请求同时注入
// X-API-Key=<connector>(让 connectorAuth 放行)+ X-Principal=<实际 caller>
// 让 principalFromRequest 走 X-Principal 分支,读 filter 按真实身份工作。
func TestIntegration_MCPRead_RespectsPrincipal(t *testing.T) {
env, _ := setupTestEnv(t)
seedConnectorForTest(t)
hMgr := map[string]string{"X-Principal": "manager"}
// 建一个含 L0/L1/L3 三档的测试类型 + 3 个实例
key := "test_mcp_read_principal"
t.Cleanup(func() {
env.httpDo(t, "DELETE", "/api/v1/ontology/object-types/"+key, nil, hMgr)
})
if code, _ := env.httpDo(t, "POST", "/api/v1/ontology/object-types",
map[string]any{
"api_name": key, "display_name": "测试 MCP 读 principal",
"classification_property": "lvl",
"classification_levels": []string{"L0", "L1", "L3"},
"classification_default": "L0",
}, hMgr); code != 201 {
t.Fatalf("create type failed: %d", code)
}
env.httpDo(t, "POST", "/api/v1/ontology/object-types/"+key+"/properties",
map[string]any{"api_name": "lvl", "display_name": "级别", "data_type": "string",
"enum_values": []string{"L0", "L1", "L3"}}, hMgr)
for _, c := range []struct{ pk, lvl string }{
{"a_l0", "L0"}, {"a_l1", "L1"}, {"a_l3", "L3"},
} {
code, body := env.httpDo(t, "POST", "/api/v1/objects",
map[string]any{"type": key, "pk": c.pk, "properties": map[string]any{"lvl": c.lvl}},
hMgr)
if code >= 300 {
t.Fatalf("create %s 失败 code=%d body=%v", c.pk, code, body)
}
// 显式写入 object_markings,让 classification 物化到 L3
env.httpDo(t, "PUT", "/api/v1/access/objects/"+key+"/"+c.pk+"/markings",
map[string]any{"markings": []string{c.lvl}}, hMgr)
}
// 3) 通过 MCP /api/v1/mcp 调 get_objects_by_type:connector 身份(X-API-Key: connector_key)应见 2
_, bodyC := env.httpDo(t, "POST", "/api/v1/mcp",
map[string]any{
"jsonrpc": "2.0", "id": "1", "method": "tools/call",
"params": map[string]any{
"name": "get_objects_by_type",
"arguments": map[string]any{"type": key, "limit": 50},
},
}, map[string]string{"X-API-Key": "test-connector-key-do-not-use-in-prod"})
connectorCount := extractCount(t, bodyC)
if connectorCount != 2 {
t.Errorf("connector 走 MCP get_objects_by_type 应见 2 条(L0+L1), got %d body=%v", connectorCount, bodyC)
}
// 4) manager 身份走 MCP:应见 3(豁免)
_, bodyM := env.httpDo(t, "POST", "/api/v1/mcp",
map[string]any{
"jsonrpc": "2.0", "id": "2", "method": "tools/call",
"params": map[string]any{
"name": "get_objects_by_type",
"arguments": map[string]any{"type": key, "limit": 50},
},
}, map[string]string{"X-API-Key": "test-manager-key-do-not-use-in-prod"})
managerCount := extractCount(t, bodyM)
if managerCount != 3 {
t.Errorf("manager 走 MCP get_objects_by_type 应见 3 条(含 L3), got %d body=%v", managerCount, bodyM)
}
// 5) analyst 身份(L0 only)走 MCP:应见 1
_, bodyA := env.httpDo(t, "POST", "/api/v1/mcp",
map[string]any{
"jsonrpc": "2.0", "id": "3", "method": "tools/call",
"params": map[string]any{
"name": "get_objects_by_type",
"arguments": map[string]any{"type": key, "limit": 50},
},
}, map[string]string{"X-API-Key": "test-analyst-key-do-not-use-in-prod"})
analystCount := extractCount(t, bodyA)
if analystCount != 1 {
t.Errorf("analyst 走 MCP get_objects_by_type 应见 1 条(L0 only), got %d body=%v", analystCount, bodyA)
}
}
// TestIntegration_MCPRead_QueryRelatedPrincipal 通过 MCP /api/v1/mcp 端点
// 验证 callConn 修复:manager 走 query_related 应能见 L3,connector 只能见 L0。
func TestIntegration_MCPRead_QueryRelatedPrincipal(t *testing.T) {
env, _ := setupTestEnv(t)
seedConnectorForTest(t)
hMgr := map[string]string{"X-Principal": "manager"}
key := "test_mcp_query_related"
t.Cleanup(func() {
env.httpDo(t, "DELETE", "/api/v1/ontology/object-types/"+key, nil, hMgr)
})
if code, _ := env.httpDo(t, "POST", "/api/v1/ontology/object-types",
map[string]any{
"api_name": key, "display_name": "MCP query 测试",
"classification_property": "lvl",
"classification_levels": []string{"L0", "L3"},
"classification_default": "L0",
}, hMgr); code != 201 {
t.Fatalf("create type failed: %d", code)
}
env.httpDo(t, "POST", "/api/v1/ontology/object-types/"+key+"/properties",
map[string]any{"api_name": "lvl", "display_name": "级别", "data_type": "string",
"enum_values": []string{"L0", "L3"}}, hMgr)
for _, c := range []struct{ pk, lvl string }{
{"a_l0", "L0"}, {"a_l3", "L3"},
} {
env.httpDo(t, "POST", "/api/v1/objects",
map[string]any{"type": key, "pk": c.pk, "properties": map[string]any{"lvl": c.lvl}, "via": "test"},
hMgr)
env.httpDo(t, "PUT", "/api/v1/access/objects/"+key+"/"+c.pk+"/markings",
map[string]any{"markings": []string{c.lvl}}, hMgr)
}
// manager 走 query_related
code, body := env.httpDo(t, "POST", "/api/v1/mcp",
map[string]any{
"jsonrpc": "2.0", "id": "1", "method": "tools/call",
"params": map[string]any{
"name": "query_related",
"arguments": map[string]any{"type": key, "limit": 50},
},
}, map[string]string{"X-API-Key": "test-manager-key-do-not-use-in-prod"})
if code != 200 {
t.Fatalf("query_related 应 200, got %d body=%v", code, body)
}
result := body["result"].(map[string]any)
content := result["content"].([]any)
text := content[0].(map[string]any)["text"].(string)
if !strings.Contains(text, `"count":2`) {
t.Errorf("manager query_related 应见 count=2, got %s", text)
}
// connector 走 query_related:应见 1(L0 only)
code, body = env.httpDo(t, "POST", "/api/v1/mcp",
map[string]any{
"jsonrpc": "2.0", "id": "2", "method": "tools/call",
"params": map[string]any{
"name": "query_related",
"arguments": map[string]any{"type": key, "limit": 50},
},
}, map[string]string{"X-API-Key": "test-connector-key-do-not-use-in-prod"})
if code != 200 {
t.Fatalf("query_related 应 200, got %d", code)
}
result2 := body["result"].(map[string]any)
content2 := result2["content"].([]any)
text2 := content2[0].(map[string]any)["text"].(string)
if !strings.Contains(text2, `"count":1`) {
t.Errorf("connector query_related 应见 count=1, got %s", text2)
}
}
// TestIntegration_UpdatePrincipal_NotTouchKeyHasAPIEchoTrue 修复 issue #8 附注:
// PUT /access/principals/:name 只传 description 不传 api_key 时,响应 has_api_key
// 应反映 DB 真实状态,而非误报 false。
func TestIntegration_UpdatePrincipal_NotTouchKeyHasAPIEchoTrue(t *testing.T) {
env, _ := setupTestEnv(t)
h := map[string]string{"X-Principal": "manager"}
key := "test_not_touch_key"
t.Cleanup(func() {
env.httpDo(t, "DELETE", "/api/v1/access/principals/"+key, nil, h)
})
// 建主体并显式设个 key
if code, _ := env.httpDo(t, "POST", "/api/v1/access/principals",
map[string]any{"name": key, "description": "初始", "generate_api_key": true}, h); code != 201 {
t.Fatalf("create failed: %d", code)
}
// PUT 只改 description,不动 key
code, body := env.httpDo(t, "PUT", "/api/v1/access/principals/"+key,
map[string]any{"description": "只改 desc"}, h)
if code != 200 {
t.Fatalf("PUT 应 200, got %d", code)
}
if hasKey, _ := body["has_api_key"].(bool); !hasKey {
t.Errorf("PUT 不动 key 时 has_api_key 应保持 true, got body=%v", body)
}
// 再 GET 确认 key 还在
_, get := env.httpDo(t, "GET", "/api/v1/access/principals/"+key, nil, h)
if hasKey, _ := get["has_api_key"].(bool); !hasKey {
t.Errorf("GET 复查 has_api_key 应 true, got %v", get)
}
}
+23 -4
View File
@@ -109,6 +109,8 @@ func run() error {
// Dynamic Security 审计日志中间件(自动记录每次请求的访问决策)
r.Use(a.accessLogMiddleware())
startAccessLogFlusher(pool)
// access_log 保留策略(2026-09-11):默认 90 天,ACCESS_LOG_RETENTION_DAYS 覆盖
startAccessLogRetention(pool, cfg.AccessLogRetentionDays)
// 物化层调度器(P2-1):后台 ticker 定期刷新 interval 物化
startMaterializationScheduler(context.Background(), a)
@@ -337,6 +339,15 @@ func registerRoutes(r *gin.Engine, a *app) {
acc.GET("/log/stats", a.accessLogStats)
}
// 使用分析(2026-09-11):本体总体/分项使用、用户活跃、共享情况(仅 manager)
ana := mgmt.Group("/analytics")
{
ana.GET("/overview", a.analyticsOverview)
ana.GET("/types", a.analyticsTypes)
ana.GET("/users", a.analyticsUsers)
ana.GET("/sharing", a.analyticsSharing)
}
// 数据备份(v1.3.0):仅 manager 主体可访问,含 create/inspect/list/download/diff/delete
// 不提供 restore 到线上——MCP 客户端拿到 dump 后在另一实例验证恢复路径
bkp := mgmt.Group("/backups")
@@ -388,8 +399,15 @@ func (a *app) loginRequired() gin.HandlerFunc {
}
}
// connectorAuth 连接器入口鉴权:connector 主体已配置 api_key 时须在 X-API-Key(或 key 查询参数)
// 携带该 key;未配置 key 的部署则放行(兼容无密钥只读场景)。
// connectorAuth 连接器入口鉴权:key 是「任意主体的有效 api_key」即可放行(修复 issue #8 v2)。
//
// 历史:早期只接受 name='connector' 的 key(连接器入口 = 单一 connector 身份)。
// v2:放宽到任一主体的 key——既然 manager / connector / analyst 等各有 api_key,
// 连接器入口就应当接受调用方的真实身份,让 principalFromRequest 按真实主体解析,
// 读路径的 visibility / classification filter 即按真实身份工作(manager 豁免、
// connector/analyst 按各自 clearance 子集)。
//
// 未提供 key 时:若全库任意主体已配置 key 则要求带(401),全库无 key 则放行(无密钥只读场景)。
func (a *app) connectorAuth() gin.HandlerFunc {
return func(c *gin.Context) {
key := c.GetHeader("X-API-Key")
@@ -397,7 +415,8 @@ func (a *app) connectorAuth() gin.HandlerFunc {
key = c.Query("key")
}
if key == "" {
if a.principalKeySet("connector") {
// 无 key:若任意主体已有 key,则视为必须带 key;否则放行(无密钥只读兼容)
if a.anyPrincipalKeySet() {
c.AbortWithStatusJSON(401, gin.H{"error": "连接器接口需要 X-API-Key"})
return
}
@@ -406,7 +425,7 @@ func (a *app) connectorAuth() gin.HandlerFunc {
}
var name string
if err := a.pool.QueryRow(c,
"SELECT name FROM principals WHERE name='connector' AND api_key=$1", key).Scan(&name); err == nil && name != "" {
"SELECT name FROM principals WHERE api_key=$1", key).Scan(&name); err == nil && name != "" {
c.Next()
return
}
+123
View File
@@ -0,0 +1,123 @@
package main
// 本体 schema 层审计(2026-09-11)
//
// 实例级变更已有 object_changes(字段级 diff + 快照),但 schema 层
// (对象类型 / 属性 / 链接类型 / 链接属性 / 动作类型)此前只有 access_log 的
// method+path 间接痕迹,没有 before/after 内容 —— 本文件补齐:
// - 全部 schema 增删改写入 ontology_audit_log(target_pk 落库)
// - update/delete 记录变更前快照(before),create 记录输入(after)
// 失败只打日志,不阻断主流程(与 recordChange 同策略)。
import (
"context"
"encoding/json"
"log"
"github.com/gin-gonic/gin"
)
// schemaAudit 写一条 schema 层审计记录。
func (a *app) schemaAudit(c *gin.Context, action, targetType, targetPK string, details map[string]any) {
actor := a.principalFromRequest(c)
if actor == "" {
actor = "anonymous"
}
if details == nil {
details = map[string]any{}
}
b, _ := json.Marshal(details)
if _, err := a.pool.Exec(context.Background(),
`INSERT INTO ontology_audit_log(actor, action, target_type, target_pk, details, affected_rows)
VALUES($1,$2,$3,$4,$5::jsonb,$6)`,
actor, action, targetType, targetPK, string(b), 1); err != nil {
log.Printf("[schema_audit] 写入失败 %s %s/%s: %v", action, targetType, targetPK, err)
}
}
// toMap 结构体 → map(审计 details 用,nil 安全)。
func toMap(v any) map[string]any {
if v == nil {
return nil
}
b, err := json.Marshal(v)
if err != nil {
return nil
}
var m map[string]any
_ = json.Unmarshal(b, &m)
return m
}
// objectTypeSnapshot 读取对象类型(含属性)当前状态,作 update/delete 的 before 快照。
func (a *app) objectTypeSnapshot(c *gin.Context, name string) map[string]any {
o, err := loadObjectType(c, a.pool, name)
if err != nil {
return nil
}
return toMap(o)
}
// propertySnapshot 按 properties.id 读取属性当前状态(含所属类型 api_name)。
func (a *app) propertySnapshot(c *gin.Context, id int64) map[string]any {
var p Property
var enum, defVal []byte
var typeName string
err := a.pool.QueryRow(c, `
SELECT p.id, p.object_type_id, p.api_name, p.display_name, p.data_type, p.required,
p.enum_values, p.description, p.format, p.default_value, p.indexable,
p.vector_index, p.backing_column, COALESCE(p.sensitivity,''), ot.api_name
FROM properties p JOIN object_types ot ON ot.id = p.object_type_id
WHERE p.id=$1`, id).
Scan(&p.ID, &p.ObjectID, &p.APIName, &p.DisplayName, &p.DataType, &p.Required,
&enum, &p.Description, &p.Format, &defVal, &p.Indexable,
&p.VectorIndex, &p.BackingColumn, &p.Sensitivity, &typeName)
if err != nil {
return nil
}
p.EnumValues = parseStringArray(enum)
p.DefaultValue = jsonRaw(defVal)
m := toMap(p)
if m != nil {
m["object_type"] = typeName
}
return m
}
// linkTypeSnapshot 读取链接类型当前状态。
func (a *app) linkTypeSnapshot(c *gin.Context, name string) map[string]any {
var l LinkType
err := a.pool.QueryRow(c, `
SELECT id, api_name, display_name, source_type, target_type, cardinality,
COALESCE(description,''), directional, COALESCE(source_property,''), COALESCE(target_property,'')
FROM link_types WHERE api_name=$1`, name).
Scan(&l.ID, &l.APIName, &l.DisplayName, &l.SourceType, &l.TargetType, &l.Cardinality,
&l.Description, &l.Directional, &l.SourceProperty, &l.TargetProperty)
if err != nil {
return nil
}
return toMap(l)
}
// linkPropertySnapshot 按 link_properties.id 读取链接属性当前状态(含所属链接类型 api_name)。
func (a *app) linkPropertySnapshot(c *gin.Context, id int64) map[string]any {
var p LinkProperty
var enum []byte
var ltName string
err := a.pool.QueryRow(c, `
SELECT p.id, p.link_type_id, p.api_name, p.display_name, p.data_type, p.required,
p.enum_values, COALESCE(p.description,''), lt.api_name
FROM link_properties p JOIN link_types lt ON lt.id = p.link_type_id
WHERE p.id=$1`, id).
Scan(&p.ID, &p.LinkTypeID, &p.APIName, &p.DisplayName, &p.DataType, &p.Required,
&enum, &p.Description, &ltName)
if err != nil {
return nil
}
p.EnumValues = parseStringArray(enum)
m := toMap(p)
if m != nil {
m["link_type"] = ltName
}
return m
}
+2
View File
@@ -31,6 +31,7 @@
<el-tabs v-model="active" class="main-tabs">
<el-tab-pane label="概览" name="overview"><OverviewView @goto="goto" /></el-tab-pane>
<el-tab-pane label="使用分析" name="analytics"><AnalyticsView /></el-tab-pane>
<el-tab-pane label="本体编辑" name="ontology"><OntologyView /></el-tab-pane>
<el-tab-pane label="实例管理" name="instances"><InstanceView /></el-tab-pane>
<el-tab-pane label="知识管理" name="ai"><AIView @refresh="refreshOverview" /></el-tab-pane>
@@ -78,6 +79,7 @@
import { ref, reactive, onMounted, watch } from 'vue'
import { ElMessage, ElMessageBox } from 'element-plus'
import OverviewView from './views/OverviewView.vue'
import AnalyticsView from './views/AnalyticsView.vue'
import OntologyView from './views/OntologyView.vue'
import InstanceView from './views/InstanceView.vue'
import AIView from './views/AIView.vue'
+6
View File
@@ -171,6 +171,12 @@ export const api = {
},
accessLogStats: () => request('GET', '/access/log/stats'),
// 使用分析(2026-09-11):本体总体/分项使用、用户活跃、共享情况
analyticsOverview: (days = 30) => request('GET', `/analytics/overview?days=${days}`),
analyticsTypes: (days = 30) => request('GET', `/analytics/types?days=${days}`),
analyticsUsers: (days = 30) => request('GET', `/analytics/users?days=${days}`),
analyticsSharing: (days = 30) => request('GET', `/analytics/sharing?days=${days}`),
// ---- 账号密码登录与会话 ----
// dev 模式下也支持登录(与 X-API-Key 并存)。登录后浏览器自动带 cookie;
// 后端 principalFromRequest 优先识别 cookie → 命名主体。
+269 -254
View File
@@ -1,58 +1,28 @@
<template>
<div class="app">
<aside class="sidebar">
<div class="brand">
<div class="brand-icon">SS</div>
<div><div class="brand-text">本体平台</div><div class="brand-sub">导入核对工作台</div></div>
</div>
<nav class="nav">
<div class="nav-title">分类</div>
<div class="nav-item" :class="{active: currentFilter==='all'}" @click="currentFilter='all'"><span>全部</span><span class="count">{{counts.all}}</span></div>
<div class="nav-item" :class="{active: currentFilter==='missing-type'}" @click="currentFilter='missing-type'"><span>缺失元原语</span><span class="count">{{counts['missing-type']}}</span></div>
<div class="nav-item" :class="{active: currentFilter==='missing-instance'}" @click="currentFilter='missing-instance'"><span>缺实例</span><span class="count">{{counts['missing-instance']}}</span></div>
<div class="nav-item" :class="{active: currentFilter==='stale'}" @click="currentFilter='stale'"><span>过期不一致</span><span class="count">{{counts.stale}}</span></div>
<div class="nav-item" :class="{active: currentFilter==='relation'}" @click="currentFilter='relation'"><span>缺关系</span><span class="count">{{counts.relation}}</span></div>
<div class="nav-item" :class="{active: currentFilter==='__other'}" @click="currentFilter='__other'"><span>其他</span><span class="count">{{counts['__other']}}</span></div>
<div class="nav-title" style="margin-top:14px">执行方式</div>
<div class="nav-item" :class="{active: currentFilter==='__op'}" @click="currentFilter='__op'"><span>操作项(直连)</span><span class="count op">{{counts['__op']}}</span></div>
<div class="nav-item" :class="{active: currentFilter==='__doc'}" @click="currentFilter='__doc'"><span>文档项(导入)</span><span class="count doc">{{counts['__doc']}}</span></div>
</nav>
<div class="progress-box">
<div class="progress-ring">
<svg width="120" height="120" viewBox="0 0 120 120">
<circle class="progress-ring-bg" cx="60" cy="60" r="52"></circle>
<circle class="progress-ring-fill" cx="60" cy="60" r="52" stroke-dasharray="326.73" :stroke-dashoffset="progressOffset"></circle>
</svg>
<div class="progress-text"><div class="progress-pct">{{progressPct}}%</div><div class="progress-label">已完成</div></div>
</div>
<div class="progress-stats">
<div class="progress-stat"><div class="num">{{counts.applied}}</div><div class="lbl">已应用</div></div>
<div class="progress-stat"><div class="num">{{counts.pending}}</div><div class="lbl">待处理</div></div>
</div>
</div>
<div class="sidebar-foot">
<p>管理员打开即<b>内置</b>一份核对清单(同源示例);同事用 scan.py 生成的清单也可「导入 JSON」载入。</p>
<button class="btn" @click="reloadBuiltin">重新加载内置清单</button>
</div>
</aside>
<header class="header">
<div class="header-left">
<div><div class="page-title">导入核对清单</div><div class="page-sub">{{pageSub}}</div></div>
<!-- 修复:原版是 dark-theme SPA(自带的 sidebar + brand + 进度环 + header + main),被
ReviewView stub 直接渲染时与其它 9 个 tab 的 page-title + card 风格完全割裂。
现在去掉 app shell(sidebar/brand/progress),只保留 header + main,分类筛选折叠成
顶部一行 filter-bar;外层 ReviewView 套 page-title + card 即可与全局风格统一。 -->
<div class="wb">
<header class="wb-header">
<div class="wb-header-left">
<div class="wb-title">{{pageSub}}</div>
<span v-if="conn.canWrite!==null" class="mode-pill" :class="conn.canWrite?'mode-exec':'mode-export'">{{conn.canWrite?'可执行':'只读(导出)'}}</span>
</div>
<div class="connection">
<div class="status-line"><span class="status-dot" :class="{ok:connState==='ok', err:connState==='err'}"></span><label>MCP URL</label></div>
<div class="wb-connection">
<span class="status-dot" :class="{ok:connState==='ok', err:connState==='err'}"></span>
<label class="muted">MCP URL</label>
<input class="url" v-model="mcpUrl" placeholder="http://127.0.0.1:8081/api/v1/mcp" list="mcp-url-list" />
<datalist id="mcp-url-list">
<option value="http://127.0.0.1:8081/api/v1/mcp" />
<option value="http://127.0.0.1:9333/api/v1/mcp" />
<option value="http://localhost:9333/api/v1/mcp" />
</datalist>
<label>Key</label><input class="key" v-model="mcpKey" type="password" placeholder="任意主体的 API Key" autocomplete="off" />
<label class="muted">Key</label>
<input class="key" v-model="mcpKey" type="password" placeholder="任意主体的 API Key" autocomplete="off" />
<button class="btn" @click="testConnection">测试连接</button>
</div>
<div style="display:flex;align-items:center;gap:10px">
<div class="wb-actions">
<button class="btn" @click="fileInput?.click()">导入 JSON</button>
<input type="file" ref="fileInput" accept=".json,application/json" style="display:none" @change="onFile" />
<button class="btn" @click="exportMd">导出报告 MD</button>
@@ -61,94 +31,112 @@
</div>
</header>
<main class="main">
<div class="stats">
<div class="stat-card primary"><div class="stat-info"><div class="num">{{statRate}}%</div><div class="lbl">整体完成率</div></div><div class="stat-icon">✓</div></div>
<div class="stat-card warning"><div class="stat-info"><div class="num">{{statTodo}}</div><div class="lbl">待处理 / 处理中</div></div><div class="stat-icon">!</div></div>
<div class="stat-card success"><div class="stat-info"><div class="num">{{statDone}}</div><div class="lbl">已应用</div></div><div class="stat-icon">↓</div></div>
<div class="stat-card danger"><div class="stat-info"><div class="num">{{statFail}}</div><div class="lbl">失败 / 需手工</div></div><div class="stat-icon">×</div></div>
<!-- 顶部 4 张统计卡(原 sidebar 的 progress-ring + stats 平移上来) -->
<div class="wb-stats">
<div class="stat primary"><div class="num">{{statRate}}%</div><div class="lbl">整体完成率</div></div>
<div class="stat warning"><div class="num">{{statTodo}}</div><div class="lbl">待处理 / 处理中</div></div>
<div class="stat success"><div class="num">{{statDone}}</div><div class="lbl">已应用</div></div>
<div class="stat danger"><div class="num">{{statFail}}</div><div class="lbl">失败 / 需手工</div></div>
</div>
<!-- 分类筛选(原 sidebar 的两级 nav 折叠成单行 filter) -->
<div class="wb-filterbar">
<span class="muted">分类</span>
<button class="filter-btn" :class="{active:currentFilter==='all'}" @click="currentFilter='all'">全部 <em>{{counts.all}}</em></button>
<button class="filter-btn" :class="{active:currentFilter==='missing-type'}" @click="currentFilter='missing-type'">缺失元原语 <em>{{counts['missing-type']}}</em></button>
<button class="filter-btn" :class="{active:currentFilter==='missing-instance'}" @click="currentFilter='missing-instance'">缺实例 <em>{{counts['missing-instance']}}</em></button>
<button class="filter-btn" :class="{active:currentFilter==='stale'}" @click="currentFilter='stale'">过期不一致 <em>{{counts.stale}}</em></button>
<button class="filter-btn" :class="{active:currentFilter==='relation'}" @click="currentFilter='relation'">缺关系 <em>{{counts.relation}}</em></button>
<button class="filter-btn" :class="{active:currentFilter==='__other'}" @click="currentFilter='__other'">其他 <em>{{counts['__other']}}</em></button>
<span class="sep"></span>
<button class="filter-btn" :class="{active:currentFilter==='__op'}" @click="currentFilter='__op'">操作项 <em class="op">{{counts['__op']}}</em></button>
<button class="filter-btn" :class="{active:currentFilter==='__doc'}" @click="currentFilter='__doc'">文档项 <em class="doc">{{counts['__doc']}}</em></button>
</div>
<div v-if="banner" class="banner" :class="banner.cls" v-html="banner.html"></div>
<!-- 状态筛选条 -->
<div class="wb-toolbar">
<div class="wb-toolbar-left">
<span class="muted">状态</span>
<button class="filter-btn" :class="{active:currentStatus==='all'}" @click="currentStatus='all'">全部</button>
<button class="filter-btn" :class="{active:currentStatus==='pending'}" @click="currentStatus='pending'">待核对</button>
<button class="filter-btn" :class="{active:currentStatus==='reviewing'}" @click="currentStatus='reviewing'">修订/补充</button>
<button class="filter-btn" :class="{active:currentStatus==='applied'}" @click="currentStatus='applied'">已应用</button>
<button class="filter-btn" :class="{active:currentStatus==='skipped'}" @click="currentStatus='skipped'">已跳过</button>
<button class="filter-btn" :class="{active:currentStatus==='failed'}" @click="currentStatus='failed'">失败</button>
</div>
<div v-if="banner" class="banner" :class="banner.cls" v-html="banner.html"></div>
<div class="toolbar">
<div class="toolbar-left">
<button class="filter-btn" :class="{active:currentStatus==='all'}" @click="currentStatus='all'">全部</button>
<button class="filter-btn" :class="{active:currentStatus==='pending'}" @click="currentStatus='pending'">待核对</button>
<button class="filter-btn" :class="{active:currentStatus==='reviewing'}" @click="currentStatus='reviewing'">修订/补充</button>
<button class="filter-btn" :class="{active:currentStatus==='applied'}" @click="currentStatus='applied'">已应用</button>
<button class="filter-btn" :class="{active:currentStatus==='skipped'}" @click="currentStatus='skipped'">已跳过</button>
<button class="filter-btn" :class="{active:currentStatus==='failed'}" @click="currentStatus='failed'">失败</button>
</div>
<div class="toolbar-right">
<button class="btn btn-ghost" @click="selectAll">全选</button>
<button class="btn btn-ghost" @click="clearSelection">清空</button>
<button class="btn btn-ghost" @click="resetStatus">重置状态</button>
</div>
<div class="wb-toolbar-right">
<button class="btn btn-ghost" @click="selectAll">全选</button>
<button class="btn btn-ghost" @click="clearSelection">清空</button>
<button class="btn btn-ghost" @click="resetStatus">重置状态</button>
<button class="btn btn-ghost" @click="reloadBuiltin">重新加载内置清单</button>
</div>
</div>
<div class="table-wrap">
<div v-if="items.length===0" class="empty-state">
<div class="big">📭</div>
<div>未载入清单。点「导入 JSON」选择 scan.py 产物,或点「重新加载内置清单」。</div>
</div>
<template v-else>
<div class="table-head"><div></div><div>序号</div><div>名称 / 分类</div><div>引用</div><div>执行方式</div><div>摘要</div><div>状态</div><div>操作</div></div>
<div class="table-body">
<div v-for="it in filteredItems" :key="it.id" class="item" :class="{selected:checkedIds.has(it.id), expanded:expandedDetails.has('detail-'+it.id)}" @click="toggleDetail(it.id)">
<div class="item-check"><input type="checkbox" :checked="checkedIds.has(it.id)" @change.stop="toggleSelect(it.id)" /></div>
<div class="item-num"><div class="severity-bar" :class="'sev-'+it.severity"></div>#{{pad(it.id)}}</div>
<div class="item-name">{{it.name}}<span v-if="it.kind==='operation'" class="tag act-operation">操作 · {{methodLabel(it.method)}}</span><span v-else class="tag act-document">文档 · 导入</span></div>
<div class="item-ref"><code>{{it.ref}}</code></div>
<div class="item-action"><span class="act" :class="it.kind==='operation'?'act-operation':'act-document'">{{it.kind==='operation'?methodLabel(it.method):'Markdown 导入'}}</span></div>
<div class="item-summary">{{it.description}}</div>
<div class="item-status">
<select :value="it.status" @change.stop="setStatus(it.id, $event.target.value)">
<option value="pending">⏸ 待核对</option>
<option value="reviewing">🔍 修订/补充</option>
<option value="applied">✓ 已应用</option>
<option value="skipped">⏭ 跳过</option>
<option value="failed">✗ 失败</option>
</select>
</div>
<div class="item-actions">
<button class="btn btn-primary" :disabled="conn.canWrite!==true" :title="conn.canWrite!==true?'当前身份无写权限,请导出清单交管理员执行':''" @click.stop="applyItem(it.id)">{{it.kind==='operation'?'应用(MCP)':'导入文档'}}</button>
</div>
<div v-if="expandedDetails.has('detail-'+it.id)" class="detail"><div class="detail-inner">
<div class="detail-cols">
<div class="detail-block"><h4>现状</h4><p>{{it.now || '(操作项无现状字段)'}}</p></div>
<div class="detail-block"><h4>应有</h4><p>{{it.should || '(操作项无应有字段)'}}</p></div>
<div class="detail-block"><h4>影响 / 理由</h4><p>{{it.rationale || '(见描述)'}}</p></div>
</div>
<div class="detail-full" v-if="it.kind==='operation'">
<div class="detail-row"><label>方法 (method)</label><input type="text" :value="it.method" readonly /></div>
<div class="detail-row"><label>参数 (params)</label><textarea readonly :value="JSON.stringify(it.params,null,2)"></textarea></div>
</div>
<div class="detail-full" v-else>
<div class="detail-row"><label>文件名</label><input type="text" :value="it.filename" readonly /></div>
<div class="detail-row"><label>Markdown 内容</label><textarea readonly :value="it.markdown"></textarea></div>
</div>
<div class="detail-actions">
<button class="btn btn-primary" :disabled="conn.canWrite!==true" @click.stop="applyItem(it.id)">▶ {{it.kind==='operation'?'直接应用(MCP)':'导入文档'}}</button>
<button class="btn btn-ghost" @click.stop="setStatus(it.id,'applied')">标记完成</button>
<button class="btn btn-ghost" @click.stop="setStatus(it.id,'skipped')">标记跳过</button>
<button v-if="it.result" class="btn btn-ghost" @click.stop="viewResult(it.id)">查看结果</button>
</div>
</div></div>
<div class="wb-table">
<div v-if="items.length===0" class="empty-state">
<div class="big">📭</div>
<div>未载入清单。点「导入 JSON」选择 scan.py 产物,或点「重新加载内置清单」。</div>
</div>
<template v-else>
<div class="table-head"><div></div><div>序号</div><div>名称 / 分类</div><div>引用</div><div>执行方式</div><div>摘要</div><div>状态</div><div>操作</div></div>
<div class="table-body">
<div v-for="it in filteredItems" :key="it.id" class="item" :class="{selected:checkedIds.has(it.id), expanded:expandedDetails.has('detail-'+it.id)}" @click="toggleDetail(it.id)">
<div class="item-check"><input type="checkbox" :checked="checkedIds.has(it.id)" @change.stop="toggleSelect(it.id)" /></div>
<div class="item-num"><div class="severity-bar" :class="'sev-'+it.severity"></div>#{{pad(it.id)}}</div>
<div class="item-name">{{it.name}}<span v-if="it.kind==='operation'" class="tag act-operation">操作 · {{methodLabel(it.method)}}</span><span v-else class="tag act-document">文档 · 导入</span></div>
<div class="item-ref"><code>{{it.ref}}</code></div>
<div class="item-action"><span class="act" :class="it.kind==='operation'?'act-operation':'act-document'">{{it.kind==='operation'?methodLabel(it.method):'Markdown 导入'}}</span></div>
<div class="item-summary">{{it.description}}</div>
<div class="item-status">
<el-select :model-value="it.status" size="small" @change.stop="(v) => setStatus(it.id, v)" style="width:100%">
<el-option label="⏸ 待核对" value="pending" />
<el-option label="🔍 修订/补充" value="reviewing" />
<el-option label="✓ 已应用" value="applied" />
<el-option label="⏭ 跳过" value="skipped" />
<el-option label="✗ 失败" value="failed" />
</el-select>
</div>
<div v-if="filteredItems.length===0" class="empty-state" style="padding:30px 20px"><div>无匹配项</div></div>
<div class="item-actions">
<el-button size="small" type="primary" :disabled="conn.canWrite!==true" :title="conn.canWrite!==true?'当前身份无写权限,请导出清单交管理员执行':''" @click.stop="applyItem(it.id)">{{it.kind==='operation'?'应用(MCP)':'导入文档'}}</el-button>
</div>
<div v-if="expandedDetails.has('detail-'+it.id)" class="detail"><div class="detail-inner">
<div class="detail-cols">
<div class="detail-block"><h4>现状</h4><p>{{it.now || '(操作项无现状字段)'}}</p></div>
<div class="detail-block"><h4>应有</h4><p>{{it.should || '(操作项无应有字段)'}}</p></div>
<div class="detail-block"><h4>影响 / 理由</h4><p>{{it.rationale || '(见描述)'}}</p></div>
</div>
<div class="detail-full" v-if="it.kind==='operation'">
<div class="detail-row"><label>方法 (method)</label><input type="text" :value="it.method" readonly /></div>
<div class="detail-row"><label>参数 (params)</label><textarea readonly :value="JSON.stringify(it.params,null,2)"></textarea></div>
</div>
<div class="detail-full" v-else>
<div class="detail-row"><label>文件名</label><input type="text" :value="it.filename" readonly /></div>
<div class="detail-row"><label>Markdown 内容</label><textarea readonly :value="it.markdown"></textarea></div>
</div>
<div class="detail-actions">
<el-button size="small" type="primary" :disabled="conn.canWrite!==true" @click.stop="applyItem(it.id)">▶ {{it.kind==='operation'?'直接应用(MCP)':'导入文档'}}</el-button>
<el-button size="small" @click.stop="setStatus(it.id,'applied')">标记完成</el-button>
<el-button size="small" @click.stop="setStatus(it.id,'skipped')">标记跳过</el-button>
</div>
</div></div>
</div>
</template>
</div>
<div class="log-panel">
<div class="log-head"><span>执行日志</span><button class="btn btn-ghost" style="padding:4px 10px;font-size:11px" @click="logs=[]">清空</button></div>
<div class="log-body">
<div v-for="(l,i) in logs" :key="i" class="log-line" :class="l.type">[{{l.t}}] {{l.msg}}</div>
<div v-if="logs.length===0" class="log-line">等待操作…</div>
<div v-if="filteredItems.length===0" class="empty-state" style="padding:30px 20px"><div>无匹配项</div></div>
</div>
</template>
</div>
<div class="wb-log">
<div class="log-head">
<span>执行日志</span>
<button class="btn btn-ghost" @click="logs=[]">清空</button>
</div>
</main>
<div class="log-body">
<div v-for="(l,i) in logs" :key="i" class="log-line" :class="l.type">[{{l.t}}] {{l.msg}}</div>
<div v-if="logs.length===0" class="log-line muted">等待操作…</div>
</div>
</div>
</div>
</template>
@@ -159,7 +147,7 @@ const wb = useReviewWorkbench()
const {
items, checkedIds, expandedDetails, currentFilter, currentStatus, logs, conn, connState,
mcpUrl, mcpKey, fileInput,
counts, progressPct, progressOffset, statRate, statTodo, statDone, statFail, pageSub, banner, filteredItems,
counts, statRate, statTodo, statDone, statFail, pageSub, banner, filteredItems,
toggleSelect, toggleDetail, setStatus, selectAll, clearSelection, resetStatus,
testConnection, applyItem, batchApply, exportJson, exportMd, onFile, reloadBuiltin,
methodLabel, pad
@@ -167,135 +155,162 @@ const {
</script>
<style scoped>
.app{
--bg:#030712;--surface:#111827;--surface-hover:#1f2937;--surface-raised:#18212f;
--border:#374151;--border-light:#4b5563;
--text:#f9fafb;--text-secondary:#9ca3af;--text-muted:#6b7280;
--primary:#2563eb;--primary-hover:#1d4ed8;--primary-soft:rgba(37,99,235,.12);
--accent:#06b6d4;--accent-soft:rgba(6,182,212,.12);
--success:#059669;--success-soft:rgba(5,150,105,.12);
--warning:#d97706;--warning-soft:rgba(217,119,6,.12);
--danger:#dc2626;--danger-soft:rgba(220,38,38,.12);
--purple:#7c3aed;--purple-soft:rgba(124,58,237,.12);
--radius:8px;--shadow:0 10px 30px -10px rgba(0,0,0,.5);
display:grid;grid-template-columns:248px 1fr;grid-template-rows:64px 1fr;grid-template-areas:"sidebar header" "sidebar main";
height:100%;min-height:600px;overflow:hidden;background:var(--bg);color:var(--text);
font-family:-apple-system,BlinkMacSystemFont,"Segoe UI",Roboto,"PingFang SC","Microsoft YaHei",sans-serif;font-size:13px;line-height:1.5;
.wb{
/* 跟随外层平台风格,不定义 dark 自有主题 */
display:flex; flex-direction:column; gap:14px;
}
*{box-sizing:border-box}
.sidebar{grid-area:sidebar;background:var(--surface);border-right:1px solid var(--border);display:flex;flex-direction:column;padding:20px 0;overflow-y:auto}
.brand{display:flex;align-items:center;gap:12px;padding:0 20px 24px;border-bottom:1px solid var(--border)}
.brand-icon{width:32px;height:32px;border-radius:var(--radius);background:linear-gradient(135deg,var(--primary),var(--accent));display:flex;align-items:center;justify-content:center;font-weight:700;font-size:14px;color:#fff}
.brand-text{font-weight:600;font-size:15px;letter-spacing:.2px}
.brand-sub{font-size:11px;color:var(--text-muted);margin-top:2px}
.nav{padding:16px 12px;display:flex;flex-direction:column;gap:4px;flex:1}
.nav-title{font-size:10px;text-transform:uppercase;letter-spacing:1px;color:var(--text-muted);padding:0 10px;margin-bottom:6px;font-weight:600}
.nav-item{display:flex;align-items:center;justify-content:space-between;padding:9px 12px;border-radius:6px;cursor:pointer;color:var(--text-secondary);transition:all .15s}
.nav-item:hover{background:var(--surface-hover);color:var(--text)}
.nav-item.active{background:var(--primary-soft);color:var(--primary);font-weight:500}
.nav-item .count{font-size:11px;background:var(--surface-raised);padding:2px 7px;border-radius:99px;color:var(--text-muted)}
.nav-item.active .count{background:rgba(37,99,235,.2);color:var(--primary)}
.nav-item .count.op{background:rgba(5,150,105,.18);color:#6ee7b7}
.nav-item .count.doc{background:rgba(6,182,212,.18);color:#67e8f9}
.progress-box{padding:20px;border-top:1px solid var(--border)}
.progress-ring{position:relative;width:120px;height:120px;margin:0 auto 14px}
.progress-ring svg{transform:rotate(-90deg)}
.progress-ring-bg{fill:none;stroke:var(--surface-raised);stroke-width:8}
.progress-ring-fill{fill:none;stroke:var(--primary);stroke-width:8;stroke-linecap:round;transition:stroke-dashoffset .4s ease}
.progress-text{position:absolute;inset:0;display:flex;flex-direction:column;align-items:center;justify-content:center}
.progress-pct{font-size:26px;font-weight:700;line-height:1}
.progress-label{font-size:10px;color:var(--text-muted);margin-top:4px}
.progress-stats{display:grid;grid-template-columns:1fr 1fr;gap:8px;font-size:11px}
.progress-stat{background:var(--surface-raised);padding:8px;border-radius:6px}
.progress-stat .num{font-size:15px;font-weight:600;color:var(--text)}
.progress-stat .lbl{color:var(--text-muted);margin-top:2px}
.sidebar-foot{padding:0 20px;font-size:11px;color:var(--text-muted);line-height:1.7}
.sidebar-foot .btn{margin-top:10px;width:100%;justify-content:center}
.header{grid-area:header;background:var(--surface);border-bottom:1px solid var(--border);display:flex;align-items:center;justify-content:space-between;padding:0 24px;gap:16px;flex-wrap:wrap}
.header-left{display:flex;align-items:center;gap:16px}
.page-title{font-size:16px;font-weight:600}
.page-sub{font-size:12px;color:var(--text-muted);margin-top:2px}
.connection{display:flex;align-items:center;gap:10px;font-size:12px;flex-wrap:wrap}
.connection .status-line{display:flex;align-items:center;gap:6px}
.connection label{color:var(--text-muted);font-size:11px;white-space:nowrap}
.connection input{background:var(--bg);border:1px solid var(--border);color:var(--text);padding:7px 10px;border-radius:6px;font-size:12px;outline:none;transition:border .15s}
.connection input:focus{border-color:var(--primary)}
.connection input.url{width:300px}
.connection input.key{width:130px}
.btn{display:inline-flex;align-items:center;gap:6px;padding:7px 14px;border-radius:6px;border:1px solid var(--border);background:var(--surface-raised);color:var(--text);font-size:12px;font-weight:500;cursor:pointer;transition:all .15s;white-space:nowrap}
.btn:hover{border-color:var(--border-light);background:var(--surface-hover)}
.btn-primary{background:var(--primary);border-color:var(--primary);color:#fff}
.btn-primary:hover{background:var(--primary-hover)}
.btn-success{background:var(--success);border-color:var(--success);color:#fff}
.btn-success:hover{background:#047857}
.btn-ghost{background:transparent;border-color:transparent;color:var(--text-secondary)}
.btn-ghost:hover{background:var(--surface-hover);color:var(--text)}
.btn:disabled{opacity:.45;cursor:not-allowed}
.status-dot{width:8px;height:8px;border-radius:50%;background:var(--text-muted)}
.status-dot.ok{background:var(--success)}
.status-dot.err{background:var(--danger)}
.mode-pill{font-size:11px;font-weight:600;padding:3px 10px;border-radius:99px}
.mode-exec{background:var(--success-soft);color:#6ee7b7}
.mode-export{background:var(--warning-soft);color:#fcd34d}
.main{grid-area:main;overflow:auto;padding:24px}
.stats{display:grid;grid-template-columns:repeat(4,1fr);gap:16px;margin-bottom:20px}
.stat-card{background:var(--surface);border:1px solid var(--border);border-radius:var(--radius);padding:18px 20px;display:flex;align-items:center;justify-content:space-between}
.stat-info .num{font-size:28px;font-weight:700;line-height:1}
.stat-info .lbl{font-size:12px;color:var(--text-muted);margin-top:6px}
.stat-icon{width:40px;height:40px;border-radius:var(--radius);display:flex;align-items:center;justify-content:center;font-size:18px}
.stat-card.primary .stat-icon { background: var(--primary-soft); color: var(--primary) }
.stat-card.success .stat-icon { background: var(--success-soft); color: var(--success) }
.stat-card.warning .stat-icon { background: var(--warning-soft); color: var(--warning) }
.stat-card.danger .stat-icon { background: var(--danger-soft); color: var(--danger) }
.banner{display:flex;align-items:center;gap:10px;padding:12px 16px;border-radius:var(--radius);font-size:12px;margin-bottom:16px}
.banner.exec{background:var(--success-soft);border:1px solid rgba(5,150,105,.25);color:#6ee7b7}
.banner.export{background:var(--warning-soft);border:1px solid rgba(217,119,6,.25);color:#fcd34d}
.banner.info{background:var(--primary-soft);border:1px solid rgba(37,99,235,.25);color:#93c5fd}
.toolbar{display:flex;align-items:center;justify-content:space-between;gap:12px;margin-bottom:16px;flex-wrap:wrap}
.toolbar-left,.toolbar-right{display:flex;align-items:center;gap:8px;flex-wrap:wrap}
.filter-btn{padding:6px 12px;border-radius:6px;border:1px solid var(--border);background:var(--surface);color:var(--text-secondary);font-size:12px;cursor:pointer}
.filter-btn.active{background:var(--primary-soft);border-color:rgba(37,99,235,.3);color:var(--primary)}
.table-wrap{background:var(--surface);border:1px solid var(--border);border-radius:var(--radius);overflow:hidden}
.table-head{display:grid;grid-template-columns:40px 56px 1.2fr .9fr 1.1fr 1.4fr 120px 130px;gap:12px;padding:12px 16px;background:var(--surface-raised);border-bottom:1px solid var(--border);font-size:11px;font-weight:600;color:var(--text-muted);text-transform:uppercase;letter-spacing:.5px}
.table-body{max-height:calc(100vh - 430px);overflow-y:auto}
.item{display:grid;grid-template-columns:40px 56px 1.2fr .9fr 1.1fr 1.4fr 120px 130px;gap:12px;padding:14px 16px;border-bottom:1px solid var(--border);align-items:center;transition:background .15s;cursor:pointer}
.item:hover{background:var(--surface-hover)}
.item.selected{background:rgba(37,99,235,.08)}
.item.expanded{background:var(--surface-raised)}
/* ===== header ===== */
.wb-header{
display:flex; align-items:center; justify-content:space-between; gap:14px; flex-wrap:wrap;
padding:12px 16px; background:#fff; border-radius:10px; box-shadow:0 1px 4px rgba(20,40,80,.05);
}
.wb-header-left{display:flex; align-items:center; gap:12px}
.wb-title{font-size:14px; font-weight:600; color:#1f2430}
.mode-pill{font-size:11px; font-weight:600; padding:3px 10px; border-radius:99px}
.mode-exec{background:#ecfdf5; color:#059669}
.mode-export{background:#fef3c7; color:#d97706}
.wb-connection{display:flex; align-items:center; gap:8px; font-size:12px; flex-wrap:wrap}
.wb-connection .status-dot{width:8px; height:8px; border-radius:50%; background:#cbd5e1; flex-shrink:0}
.wb-connection .status-dot.ok{background:#059669}
.wb-connection .status-dot.err{background:#dc2626}
.wb-connection label{color:#8a93a6; font-size:11px; white-space:nowrap}
.wb-connection input{
border:1px solid #dbe1ed; background:#fff; padding:5px 10px; border-radius:6px;
font-size:12px; color:#1f2430; outline:none; transition:border .15s;
}
.wb-connection input:focus{border-color:#2f6bff}
.wb-connection input.url{width:280px}
.wb-connection input.key{width:130px}
.wb-actions{display:flex; align-items:center; gap:8px; flex-wrap:wrap}
/* ===== 通用按钮(沿用平台样式基调) ===== */
.btn{
display:inline-flex; align-items:center; gap:6px; padding:6px 14px; border-radius:6px;
border:1px solid #dbe1ed; background:#fff; color:#1f2430; font-size:12px;
font-weight:500; cursor:pointer; transition:all .15s; white-space:nowrap;
}
.btn:hover{border-color:#b6c2dd; background:#f8fafc}
.btn-primary{background:#2f6bff; border-color:#2f6bff; color:#fff}
.btn-primary:hover{background:#1b3f9c; border-color:#1b3f9c}
.btn-success{background:#059669; border-color:#059669; color:#fff}
.btn-success:hover{background:#047857; border-color:#047857}
.btn-ghost{background:transparent; border-color:transparent; color:#4a5b8c}
.btn-ghost:hover{background:#eef1f7; color:#1f2430}
.btn:disabled{opacity:.45; cursor:not-allowed}
/* ===== 顶部统计卡(4 列,跟首页/概览风格一致) ===== */
.wb-stats{display:grid; grid-template-columns:repeat(4,1fr); gap:12px}
.stat{
background:#fff; border-radius:10px; padding:14px 16px;
box-shadow:0 1px 4px rgba(20,40,80,.05);
display:flex; flex-direction:column; gap:4px;
border-left:3px solid #cbd5e1;
}
.stat .num{font-size:24px; font-weight:700; color:#1f2430; line-height:1}
.stat .lbl{font-size:12px; color:#8a93a6}
.stat.primary{border-left-color:#2f6bff}
.stat.success{border-left-color:#059669}
.stat.warning{border-left-color:#d97706}
.stat.danger{border-left-color:#dc2626}
/* ===== 分类筛选 ===== */
.wb-filterbar{
display:flex; align-items:center; gap:6px; flex-wrap:wrap;
padding:10px 14px; background:#fff; border-radius:10px; box-shadow:0 1px 4px rgba(20,40,80,.05);
}
.wb-filterbar .sep{width:1px; height:18px; background:#dbe1ed; margin:0 4px}
.filter-btn{
display:inline-flex; align-items:center; gap:4px;
padding:4px 10px; border-radius:14px;
border:1px solid #dbe1ed; background:#fff; color:#4a5b8c; font-size:12px; cursor:pointer;
}
.filter-btn em{font-style:normal; background:#f1f4fa; padding:1px 6px; border-radius:8px; font-size:11px; color:#6b7693}
.filter-btn em.op{background:#ecfdf5; color:#059669}
.filter-btn em.doc{background:#ecfeff; color:#06b6d4}
.filter-btn.active{background:#eff3fc; border-color:#b6c8f0; color:#1b3f9c; font-weight:500}
.filter-btn.active em{background:#dbe4f5; color:#1b3f9c}
/* ===== banner ===== */
.banner{display:flex; align-items:center; gap:10px; padding:10px 14px; border-radius:8px; font-size:12px}
.banner.exec{background:#ecfdf5; border:1px solid #a7f3d0; color:#065f46}
.banner.export{background:#fef3c7; border:1px solid #fde68a; color:#92400e}
.banner.info{background:#eff6ff; border:1px solid #bfdbfe; color:#1e3a8a}
/* ===== 状态筛选条 ===== */
.wb-toolbar{
display:flex; align-items:center; justify-content:space-between; gap:12px; flex-wrap:wrap;
padding:10px 14px; background:#fff; border-radius:10px; box-shadow:0 1px 4px rgba(20,40,80,.05);
}
.wb-toolbar-left, .wb-toolbar-right{display:flex; align-items:center; gap:6px; flex-wrap:wrap}
/* ===== 表格 ===== */
.wb-table{
background:#fff; border-radius:10px; box-shadow:0 1px 4px rgba(20,40,80,.05);
overflow:hidden;
}
.table-head{
display:grid; grid-template-columns:36px 56px 1.2fr .9fr 1fr 1.4fr 130px 110px; gap:12px;
padding:10px 14px; background:#f7f9fc; border-bottom:1px solid #eef1f7;
font-size:11px; font-weight:600; color:#8a93a6;
}
.table-body{max-height:calc(100vh - 480px); overflow-y:auto}
.item{
display:grid; grid-template-columns:36px 56px 1.2fr .9fr 1fr 1.4fr 130px 110px; gap:12px;
padding:12px 14px; border-bottom:1px solid #eef1f7; align-items:center;
transition:background .15s; cursor:pointer;
}
.item:hover{background:#fafbfd}
.item.selected{background:#eff3fc}
.item.expanded{background:#f7f9fc}
.item:last-child{border-bottom:none}
.item-check{display:flex;align-items:center;justify-content:center}
.item-check input{width:16px;height:16px;accent-color:var(--primary);cursor:pointer}
.item-num{font-size:12px;color:var(--text-muted);font-variant-numeric:tabular-nums;display:flex;align-items:center;gap:6px}
.severity-bar{width:3px;height:36px;border-radius:2px}
.sev-red{background:var(--danger)}.sev-amber{background:var(--warning)}.sev-orange{background:#ea580c}.sev-emerald{background:var(--success)}.sev-blue{background:var(--primary)}
.item-name{font-weight:500;color:var(--text);line-height:1.4}
.item-name .tag{display:inline-block;font-size:10px;font-weight:500;padding:2px 7px;border-radius:4px;margin-left:8px;vertical-align:middle}
.item-ref{font-size:12px;color:var(--text-secondary)}
.item-ref code{background:var(--bg);padding:2px 5px;border-radius:4px;font-size:11px}
.item-check{display:flex; align-items:center; justify-content:center}
.item-check input{width:16px; height:16px; accent-color:#2f6bff; cursor:pointer}
.item-num{font-size:12px; color:#6b7693; font-variant-numeric:tabular-nums; display:flex; align-items:center; gap:6px}
.severity-bar{width:3px; height:32px; border-radius:2px}
.sev-red{background:#dc2626}.sev-amber{background:#d97706}.sev-orange{background:#ea580c}.sev-emerald{background:#059669}.sev-blue{background:#2f6bff}
.item-name{font-weight:500; color:#1f2430; line-height:1.4}
.item-name .tag{display:inline-block; font-size:10px; font-weight:500; padding:2px 7px; border-radius:4px; margin-left:8px; vertical-align:middle}
.item-name .tag.act-operation{background:#fee2e2; color:#b91c1c}
.item-name .tag.act-document{background:#cffafe; color:#0e7490}
.item-ref{font-size:12px; color:#4a5b8c}
.item-ref code{background:#f1f4fa; padding:2px 6px; border-radius:4px; font-size:11px; color:#1f2430}
.item-action{font-size:11px}
.item-action .act{display:inline-block;padding:3px 8px;border-radius:4px;font-weight:500}
.act-operation{background:var(--danger-soft);color:#fca5a5}
.act-document{background:var(--accent-soft);color:#67e8f9}
.item-summary{font-size:12px;color:var(--text-secondary);line-height:1.5;overflow:hidden;display:-webkit-box;-webkit-line-clamp:2;-webkit-box-orient:vertical}
.item-status select{background:var(--bg);border:1px solid var(--border);color:var(--text);padding:6px 8px;border-radius:6px;font-size:12px;width:100%;outline:none;cursor:pointer}
.item-actions{display:flex;gap:6px}
.item-actions .btn{padding:5px 10px;font-size:11px}
.detail{grid-column:1/-1;background:var(--bg);border-top:1px dashed var(--border);padding:0}
.detail-inner{padding:18px 16px 20px 112px}
.detail-cols{display:grid;grid-template-columns:repeat(3,1fr);gap:20px;margin-bottom:18px}
.detail-block h4{font-size:11px;text-transform:uppercase;letter-spacing:.5px;color:var(--text-muted);margin:0 0 8px;font-weight:600}
.detail-block p{margin:0;font-size:12px;color:var(--text-secondary);line-height:1.7}
.detail-row{display:grid;grid-template-columns:200px 1fr;gap:12px;align-items:start;margin-bottom:12px}
.detail-row label{font-size:11px;color:var(--text-muted);padding-top:7px}
.detail-row input,.detail-row textarea{background:var(--surface);border:1px solid var(--border);color:var(--text);padding:7px 10px;border-radius:6px;font-size:12px;outline:none;width:100%}
.detail-row input:focus,.detail-row textarea:focus{border-color:var(--primary)}
.detail-row textarea{min-height:80px;resize:vertical;font-family:inherit;line-height:1.6}
.detail-actions{display:flex;gap:10px;margin-top:16px;padding-top:16px;border-top:1px solid var(--border);flex-wrap:wrap}
.log-panel{background:var(--surface);border:1px solid var(--border);border-radius:var(--radius);margin-top:20px;max-height:240px;display:flex;flex-direction:column}
.log-head{display:flex;align-items:center;justify-content:space-between;padding:10px 14px;border-bottom:1px solid var(--border);font-size:12px;font-weight:600}
.log-body{flex:1;overflow:auto;padding:10px 14px;font-family:ui-monospace,SFMono-Regular,Menlo,monospace;font-size:11px;line-height:1.6}
.log-line{margin-bottom:6px;color:var(--text-secondary)}
.log-line.ok{color:var(--success)}.log-line.err{color:#fca5a5}.log-line.warn{color:#fcd34d}.log-line.info{color:var(--accent)}
.empty-state{text-align:center;padding:60px 20px;color:var(--text-muted)}
.empty-state .big{font-size:40px;margin-bottom:12px}
.item-action .act{display:inline-block; padding:3px 8px; border-radius:4px; font-weight:500}
.act-operation{background:#fee2e2; color:#b91c1c}
.act-document{background:#cffafe; color:#0e7490}
.item-summary{font-size:12px; color:#4a5b8c; line-height:1.5; overflow:hidden; display:-webkit-box; -webkit-line-clamp:2; -webkit-box-orient:vertical}
.item-actions{display:flex; gap:6px}
.item-actions :deep(.el-button){padding:5px 10px !important; font-size:11px !important}
/* ===== 展开详情 ===== */
.detail{grid-column:1/-1; background:#fafbfd; border-top:1px dashed #eef1f7}
.detail-inner{padding:16px 14px 18px 90px}
.detail-cols{display:grid; grid-template-columns:repeat(3,1fr); gap:18px; margin-bottom:16px}
.detail-block h4{font-size:11px; text-transform:uppercase; letter-spacing:.5px; color:#8a93a6; margin:0 0 6px; font-weight:600}
.detail-block p{margin:0; font-size:12px; color:#4a5b8c; line-height:1.7}
.detail-row{display:grid; grid-template-columns:160px 1fr; gap:12px; align-items:start; margin-bottom:10px}
.detail-row label{font-size:11px; color:#6b7693; padding-top:7px}
.detail-row input, .detail-row textarea{
border:1px solid #dbe1ed; background:#fff; padding:6px 10px; border-radius:6px;
font-size:12px; color:#1f2430; outline:none; width:100%;
}
.detail-row input:focus, .detail-row textarea:focus{border-color:#2f6bff}
.detail-row textarea{min-height:80px; resize:vertical; font-family:inherit; line-height:1.6}
.detail-actions{display:flex; gap:10px; margin-top:14px; padding-top:14px; border-top:1px solid #eef1f7; flex-wrap:wrap}
/* ===== 日志 ===== */
.wb-log{
background:#fff; border-radius:10px; box-shadow:0 1px 4px rgba(20,40,80,.05);
max-height:240px; display:flex; flex-direction:column;
}
.log-head{display:flex; align-items:center; justify-content:space-between; padding:10px 14px; border-bottom:1px solid #eef1f7; font-size:12px; font-weight:600; color:#1f2430}
.log-body{flex:1; overflow:auto; padding:10px 14px; font-family:ui-monospace,SFMono-Regular,Menlo,monospace; font-size:11px; line-height:1.6}
.log-line{margin-bottom:4px; color:#4a5b8c}
.log-line.ok{color:#059669}.log-line.err{color:#dc2626}.log-line.warn{color:#d97706}.log-line.info{color:#06b6d4}
.log-line.muted{color:#8a93a6}
/* ===== 空状态 ===== */
.empty-state{text-align:center; padding:60px 20px; color:#8a93a6}
.empty-state .big{font-size:36px; margin-bottom:10px}
.muted{color:#8a93a6}
</style>
+212
View File
@@ -0,0 +1,212 @@
<template>
<div class="page">
<div class="page-title">📈 使用分析
<span class="muted">基于访问日志 / 实例变更 / schema 审计聚合</span>
<span style="flex:1"></span>
<el-radio-group v-model="days" size="small" @change="load">
<el-radio-button :value="7">近 7 天</el-radio-button>
<el-radio-button :value="30">近 30 天</el-radio-button>
<el-radio-button :value="90">近 90 天</el-radio-button>
</el-radio-group>
<el-button size="small" @click="load" :loading="loading">刷新</el-button>
</div>
<!-- 总体 -->
<div class="row stats">
<div class="stat"><div class="num">{{ ov.total || 0 }}</div><div class="lbl">总请求</div></div>
<div class="stat"><div class="num">{{ ov.reads || 0 }}</div><div class="lbl">浏览(read)</div></div>
<div class="stat"><div class="num">{{ (ov.writes || 0) + (ov.deletes || 0) }}</div><div class="lbl">修改(write+delete)</div></div>
<div class="stat"><div class="num">{{ ov.active_users || 0 }}</div><div class="lbl">活跃主体</div></div>
<div class="stat"><div class="num">{{ ov.mcp_requests || 0 }}</div><div class="lbl">MCP 调用</div></div>
<div class="stat"><div class="num">{{ ov.conn_requests || 0 }}</div><div class="lbl">连接器</div></div>
<div class="stat"><div class="num" :class="{ danger: (ov.denies || 0) > 0 }">{{ ov.denies || 0 }}</div><div class="lbl">拒绝/脱敏</div></div>
</div>
<div class="card">
<div class="page-title">📅 按天趋势</div>
<div v-if="!ov.by_day || !ov.by_day.length" class="muted">窗口期内暂无请求记录</div>
<div v-else class="trend">
<div v-for="d in ov.by_day" :key="d.day" class="trend-col" :title="`${d.day}:请求 ${d.requests}(读 ${d.reads} / 写 ${d.writes}),活跃 ${d.users} 人`">
<div class="trend-bars">
<div class="bar read" :style="{ height: barH(d.reads) }"></div>
<div class="bar write" :style="{ height: barH(d.writes) }"></div>
</div>
<div class="trend-day">{{ d.day.slice(5) }}</div>
</div>
</div>
<div class="legend muted">
<span class="dot read"></span>浏览 <span class="dot write"></span>修改(悬停看明细)
</div>
</div>
<!-- 分项 -->
<div class="card">
<div class="page-title">🧩 本体分项使用情况(按热度排序)</div>
<el-table :data="types" size="small" empty-text="暂无对象类型" max-height="420">
<el-table-column prop="display_name" label="类型" min-width="140">
<template #default="{ row }">{{ row.display_name }} <span class="muted">{{ row.name }}</span></template>
</el-table-column>
<el-table-column prop="instances" label="实例数" width="90" sortable />
<el-table-column prop="instance_reads" label="实例浏览" width="100" sortable />
<el-table-column prop="ontology_views" label="定义浏览" width="100" sortable />
<el-table-column prop="instance_writes" label="实例修改" width="100" sortable />
<el-table-column prop="schema_changes" label="定义变更" width="100" sortable />
<el-table-column prop="last_read" label="最近浏览" width="150" />
<el-table-column prop="last_write" label="最近修改" width="150" />
</el-table>
</div>
<div class="row two-col">
<!-- 用户活跃 -->
<div class="card half">
<div class="page-title">👥 用户活跃</div>
<el-table :data="users" size="small" empty-text="无主体" max-height="420">
<el-table-column prop="principal" label="主体" min-width="110" />
<el-table-column prop="requests" label="请求" width="80" sortable />
<el-table-column prop="reads" label="读" width="70" sortable />
<el-table-column label="写/删" width="80" sortable prop="writes">
<template #default="{ row }">{{ row.writes + row.deletes }}</template>
</el-table-column>
<el-table-column prop="denies" label="拒绝" width="70">
<template #default="{ row }">
<span :class="{ danger: row.denies > 0 }">{{ row.denies }}</span>
</template>
</el-table-column>
<el-table-column prop="last_active" label="最近活跃" width="150">
<template #default="{ row }">
<el-tag v-if="!row.active" size="small" type="info" effect="plain">窗口期未活跃</el-tag>
<span v-else>{{ row.last_active }}</span>
</template>
</el-table-column>
</el-table>
</div>
<!-- 共享 -->
<div class="card half">
<div class="page-title">🔗 共享与授权使用</div>
<div class="muted" style="margin-bottom:8px">共 {{ sharing.grants?.length || 0 }} 条授权,覆盖 {{ sharing.usage?.length || 0 }} 个主体</div>
<el-table :data="sharing.usage" size="small" empty-text="无共享授权" max-height="180">
<el-table-column prop="principal" label="被共享主体" min-width="110" />
<el-table-column prop="grants" label="授权数" width="80" />
<el-table-column prop="requests" label="使用请求" width="90" sortable />
<el-table-column prop="reads" label="读" width="70" />
<el-table-column prop="writes" label="写/删" width="80" />
</el-table>
<div class="page-title" style="margin-top:14px;font-size:14px">授权明细</div>
<el-table :data="sharing.grants" size="small" max-height="180">
<el-table-column prop="principal" label="主体" min-width="100" />
<el-table-column prop="action" label="动作" width="90" />
<el-table-column label="范围" min-width="130">
<template #default="{ row }">
{{ row.scope_type === '*' ? '全部类型' : row.scope_type }}<template v-if="row.scope_pk !== '*'"> / {{ row.scope_pk }}</template>
</template>
</el-table-column>
<el-table-column prop="effect" label="效力" width="80">
<template #default="{ row }">
<el-tag size="small" :type="row.effect === 'deny' ? 'danger' : 'success'" effect="plain">{{ row.effect }}</el-tag>
</template>
</el-table-column>
<el-table-column prop="used" label="已用" width="70" sortable />
</el-table>
</div>
</div>
<!-- 最近 schema 变更 -->
<div class="card">
<div class="page-title">📝 最近本体定义变更(schema 审计)</div>
<el-table :data="ov.recent_schema" size="small" empty-text="暂无 schema 变更记录" max-height="300">
<el-table-column prop="created_at" label="时间" width="150" />
<el-table-column prop="actor" label="操作者" width="110" />
<el-table-column prop="action" label="动作" width="190">
<template #default="{ row }">
<el-tag size="small" effect="plain" :type="actionTag(row.action)">{{ actionText(row.action) }}</el-tag>
</template>
</el-table-column>
<el-table-column label="目标" min-width="220">
<template #default="{ row }">{{ row.target_type }}<template v-if="row.target_pk"> / {{ row.target_pk }}</template></template>
</el-table-column>
</el-table>
</div>
</div>
</template>
<script setup>
import { ref, onMounted } from 'vue'
import { api } from '../api.js'
const days = ref(30)
const loading = ref(false)
const ov = ref({})
const types = ref([])
const users = ref([])
const sharing = ref({})
async function load() {
loading.value = true
try {
const [o, t, u, s] = await Promise.all([
api.analyticsOverview(days.value),
api.analyticsTypes(days.value),
api.analyticsUsers(days.value),
api.analyticsSharing(days.value)
])
ov.value = o
types.value = t.types || []
users.value = u.users || []
sharing.value = s
} catch (e) {
console.error(e)
} finally {
loading.value = false
}
}
// 趋势柱状图归一化(读为主轴)
function barH(v) {
const max = Math.max(1, ...(ov.value.by_day || []).map(d => Math.max(d.reads, d.writes)))
return Math.max(2, Math.round((v / max) * 72)) + 'px'
}
function actionText(a) {
return {
object_type_create: '新建对象类型', object_type_update: '更新对象类型', object_type_delete: '删除对象类型',
object_type_classification: '分级配置', property_add: '新增属性', property_update: '更新属性', property_delete: '删除属性',
link_type_create: '新建链接类型', link_type_update: '更新链接类型', link_type_delete: '删除链接类型',
link_property_add: '新增链接属性', link_property_delete: '删除链接属性',
action_type_upsert: '保存动作类型',
analyze: '类型梳理', merge_preview: '合并预览', merge_execute: '执行合并', delete_zero_inst: '清理零实例'
}[a] || a
}
function actionTag(a) {
if (a.endsWith('_delete')) return 'danger'
if (a.endsWith('_create')) return 'success'
if (a.endsWith('_update') || a.endsWith('_upsert')) return 'warning'
return 'info'
}
onMounted(load)
</script>
<style scoped>
.stats { gap: 14px; margin-bottom: 16px; }
.stat {
flex: 1; min-width: 110px; background: #fff; border-radius: 12px; padding: 14px 16px;
box-shadow: 0 1px 6px rgba(20,40,80,.06); text-align: center;
}
.stat .num { font-size: 26px; font-weight: 800; color: var(--brand); }
.stat .lbl { font-size: 12.5px; color: #8a93a6; margin-top: 4px; }
.num.danger, .danger { color: #e0413e; }
.trend { display: flex; align-items: flex-end; gap: 4px; min-height: 110px; overflow-x: auto; }
.trend-col { display: flex; flex-direction: column; align-items: center; min-width: 26px; }
.trend-bars { display: flex; align-items: flex-end; gap: 2px; height: 80px; }
.bar { width: 9px; border-radius: 3px 3px 0 0; }
.bar.read { background: #2f6bff; }
.bar.write { background: #f0a020; }
.trend-day { font-size: 10px; color: #8a93a6; margin-top: 4px; white-space: nowrap; }
.legend { margin-top: 8px; display: flex; align-items: center; gap: 6px; }
.dot { display: inline-block; width: 10px; height: 10px; border-radius: 3px; margin-left: 8px; }
.dot.read { background: #2f6bff; }
.dot.write { background: #f0a020; }
.two-col { align-items: stretch; }
.half { flex: 1; min-width: 380px; }
</style>
+6 -1
View File
@@ -1,5 +1,10 @@
<template>
<ReviewWorkbench />
<div class="page">
<div class="page-title">✅ 导入核对 <span class="muted">· 本体 gap 清单逐项 Apply(写权限)或导出执行清单(只读身份)</span></div>
<div class="card">
<ReviewWorkbench />
</div>
</div>
</template>
<script setup>