feat(v0.14.1): 笔记组 CRUD 与画布连线/布局偏好

Author: Aparencia

app/src-tauri/src/commands_groups.rs

@@ -8,7 +8,7 @@
 use tauri::State;
 
 use crate::commands::{normalize_title, AppState};
-use crate::types::{NewNoteGroup, Note, NoteGroup};
+use crate::types::{GroupDeleteImpact, NewNoteGroup, Note, NoteGroup};
 use crate::video_profile_domain::DomainKind;
 
 /// 组类别白名单（非法值拒绝——前端枚举同口径）。
@@ -183,3 +183,53 @@ pub fn update_group_color(
         .update_group_color(id, color.as_deref())
         .map_err(|e| e.to_string())
 }
+
+/// 组删除影响面（v0.14.1；只读——确认弹窗数据源，无副作用）。
+///
+/// @ai-context: 两步删除（先 impact 后 delete）——确认弹窗展示的数量与执行时的
+///              真实状态分离，防"确认后数据漂移"造成误删语义（规格 §3.2）。
+#[tauri::command]
+pub fn get_group_delete_impact(
+    state: State<'_, AppState>,
+    id: i64,
+) -> Result<GroupDeleteImpact, String> {
+    get_group_delete_impact_inner(&state.db, id)
+}
+
+/// 删除组（v0.14.1：影响面确认后级联——单事务清理引用再删组）。
+///
+/// @ai-context: 不区分组来源（container/feed、course/topic/standalone 皆可删——
+///              误生成纠错是主诉求）；删除后组内笔记/碎片经 FK SET NULL 移入
+///              "全部"，闪卡/结算/周契约 CASCADE，体系引用显式清理。
+#[tauri::command]
+pub fn delete_note_group(state: State<'_, AppState>, id: i64) -> Result<bool, String> {
+    delete_note_group_inner(&state.db, id)
+}
+
+pub(crate) fn get_group_delete_impact_inner(
+    db: &crate::db::Db,
+    id: i64,
+) -> Result<GroupDeleteImpact, String> {
+    if id <= 0 {
+        return Err("无效的组 id".to_string());
+    }
+    if db.get_group(id).map_err(|e| e.to_string())?.is_none() {
+        return Err(format!("笔记组不存在: {}", id));
+    }
+    db.group_delete_impact(id).map_err(|e| e.to_string())
+}
+
+pub(crate) fn delete_note_group_inner(db: &crate::db::Db, id: i64) -> Result<bool, String> {
+    if id <= 0 {
+        return Err("无效的组 id".to_string());
+    }
+    if db.get_group(id).map_err(|e| e.to_string())?.is_none() {
+        return Err(format!("笔记组不存在: {}", id));
+    }
+    db.delete_group(id).map_err(|e| e.to_string())
+}
+
+/// 命令层单测独立文件（保持本文件 ≤300 行，AGENTS.md §3）。
+#[cfg(test)]
+#[path = "commands_groups_tests.rs"]
+mod tests;

app/src-tauri/src/commands_groups_tests.rs

@@ -0,0 +1,86 @@
+//! commands_groups 删除命令单测（v0.14.1；inner 纯编排——内存库 AAA 模式）。
+
+use crate::commands_groups::{delete_note_group_inner, get_group_delete_impact_inner};
+use crate::db::Db;
+use crate::types::{NewNote, NewNoteGroup};
+
+fn mem_db() -> Db {
+    Db::open(":memory:").expect("内存库打开")
+}
+
+fn group(name: &str) -> NewNoteGroup {
+    NewNoteGroup {
+        name: name.to_string(),
+        terrain: "container".to_string(),
+        kind: "standalone".to_string(),
+        domain_tag: None,
+        source: "route".to_string(),
+        series_key: None,
+        route_reason: None,
+    }
+}
+
+#[test]
+fn impact_rejects_invalid_id() {
+    // Arrange
+    let db = mem_db();
+    // Act / Assert
+    assert!(get_group_delete_impact_inner(&db, 0).is_err());
+    assert!(get_group_delete_impact_inner(&db, -1).is_err());
+}
+
+#[test]
+fn impact_rejects_missing_group() {
+    // Arrange
+    let db = mem_db();
+    // Act
+    let err = get_group_delete_impact_inner(&db, 999).expect_err("missing");
+    // Assert
+    assert!(err.contains("不存在"));
+}
+
+#[test]
+fn impact_returns_counts_for_existing_group() {
+    // Arrange：组 + 1 笔记
+    let db = mem_db();
+    let g = db.create_group(&group("将删")).expect("create");
+    db.create_note(&NewNote {
+        title: "A".to_string(),
+        content: "x".to_string(),
+        source: "manual".to_string(),
+        session_id: None,
+        rule_version: None,
+        purify_stats: None,
+        tags: None,
+        properties: None,
+        group_id: Some(g.id),
+    })
+    .expect("note");
+    // Act
+    let impact = get_group_delete_impact_inner(&db, g.id).expect("impact");
+    // Assert
+    assert_eq!(impact.notes, 1);
+    assert_eq!(impact.cards, 0);
+    assert_eq!(impact.system_refs, 0);
+}
+
+#[test]
+fn delete_rejects_invalid_and_missing() {
+    // Arrange
+    let db = mem_db();
+    // Act / Assert
+    assert!(delete_note_group_inner(&db, 0).is_err());
+    assert!(delete_note_group_inner(&db, 999).is_err());
+}
+
+#[test]
+fn delete_removes_group() {
+    // Arrange
+    let db = mem_db();
+    let g = db.create_group(&group("将删")).expect("create");
+    // Act
+    let ok = delete_note_group_inner(&db, g.id).expect("delete");
+    // Assert
+    assert!(ok);
+    assert!(db.get_group(g.id).expect("get").is_none());
+}

app/src-tauri/src/commands_knowledge_canvas.rs

@@ -16,7 +16,13 @@ use tauri::State;
 use crate::commands::AppState;
 use crate::commands_knowledge::require_id;
 use crate::db::Db;
-use crate::types::{CanvasNodePosition, CanvasViewport};
+use crate::types::{CanvasNodePosition, CanvasPrefs, CanvasViewport};
+
+/// 连线样式白名单（v0.14.1；前端枚举同口径——未知值拒绝，防字符串入库）。
+const EDGE_STYLES: [&str; 4] = ["straight", "bezier", "smoothstep", "step"];
+
+/// 布局算法白名单（v0.14.1；前端枚举同口径）。
+const LAYOUT_ALGORITHMS: [&str; 6] = ["radial", "mindmap", "treeRight", "org", "fishbone", "dualRing"];
 
 /// 保存节点画布位置（拖拽落点；防抖后调用；幂等覆盖）。
 ///
@@ -163,6 +169,61 @@ pub(crate) fn get_canvas_viewport_inner(
         .map_err(|e| e.to_string())
 }
 
+/// 读取体系画布偏好（v0.14.1；从未保存 → None——前端回落默认值）。
+#[tauri::command]
+pub fn get_canvas_prefs(state: State<'_, AppState>, system_id: i64) -> Result<Option<CanvasPrefs>, String> {
+    get_canvas_prefs_inner(&state.db, system_id)
+}
+
+/// 保存体系画布偏好（upsert；枚举白名单校验）。
+#[tauri::command]
+pub fn save_canvas_prefs(
+    state: State<'_, AppState>,
+    system_id: i64,
+    edge_style: String,
+    edge_arrows: bool,
+    layout_algorithm: String,
+) -> Result<bool, String> {
+    save_canvas_prefs_inner(&state.db, system_id, &edge_style, edge_arrows, &layout_algorithm)
+}
+
+pub(crate) fn get_canvas_prefs_inner(db: &Db, system_id: i64) -> Result<Option<CanvasPrefs>, String> {
+    require_id(system_id)?;
+    if db.get_knowledge_system(system_id).map_err(|e| e.to_string())?.is_none() {
+        return Err(format!("体系不存在: {}", system_id));
+    }
+    db.get_canvas_prefs(system_id).map_err(|e| e.to_string())
+}
+
+pub(crate) fn save_canvas_prefs_inner(
+    db: &Db,
+    system_id: i64,
+    edge_style: &str,
+    edge_arrows: bool,
+    layout_algorithm: &str,
+) -> Result<bool, String> {
+    require_id(system_id)?;
+    if db.get_knowledge_system(system_id).map_err(|e| e.to_string())?.is_none() {
+        return Err(format!("体系不存在: {}", system_id));
+    }
+    if !EDGE_STYLES.contains(&edge_style) {
+        return Err(format!(
+            "不支持的连线样式: {}（支持: {}）",
+            edge_style,
+            EDGE_STYLES.join("/")
+        ));
+    }
+    if !LAYOUT_ALGORITHMS.contains(&layout_algorithm) {
+        return Err(format!(
+            "不支持的布局算法: {}（支持: {}）",
+            layout_algorithm,
+            LAYOUT_ALGORITHMS.join("/")
+        ));
+    }
+    db.save_canvas_prefs(system_id, edge_style, edge_arrows, layout_algorithm)
+        .map_err(|e| e.to_string())
+}
+
 /// 命令层单测独立文件（保持本文件 ≤300 行，AGENTS.md §3）。
 #[cfg(test)]
 #[path = "commands_knowledge_canvas_tests.rs"]

app/src-tauri/src/commands_knowledge_canvas_tests.rs

@@ -7,8 +7,8 @@
 //!              ③ 坐标有限值/zoom 正数校验（NaN/Infinity/0/负值/超界拒绝）。
 
 use crate::commands_knowledge_canvas::{
-    batch_initialize_canvas_positions_inner, get_canvas_viewport_inner,
-    save_canvas_viewport_inner, update_node_canvas_position_inner,
+    batch_initialize_canvas_positions_inner, get_canvas_prefs_inner, get_canvas_viewport_inner,
+    save_canvas_prefs_inner, save_canvas_viewport_inner, update_node_canvas_position_inner,
 };
 use crate::commands_knowledge_systems::{
     add_knowledge_node_inner, create_knowledge_system_inner, list_knowledge_nodes_inner,
@@ -229,3 +229,54 @@ fn viewport_rejects_bad_zoom_and_unknown_system() {
     // 拒绝后无记录
     assert_eq!(get_canvas_viewport_inner(&db, sid).expect("读"), None);
 }
+
+#[test]
+fn canvas_prefs_save_get_roundtrip_and_default_missing() {
+    // Arrange
+    let db = mem_db();
+    let sid = make_global(&db);
+    // Act：从未保存 → None（前端回落默认 smoothstep + radial）
+    assert_eq!(get_canvas_prefs_inner(&db, sid).expect("首次读"), None);
+    // 保存 → 回读
+    save_canvas_prefs_inner(&db, sid, "bezier", true, "mindmap").expect("保存");
+    let p = get_canvas_prefs_inner(&db, sid).expect("读").expect("有记录");
+    // Assert：camelCase 契约字段与箭头布尔往返
+    assert_eq!(p.edge_style, "bezier");
+    assert!(p.edge_arrows);
+    assert_eq!(p.layout_algorithm, "mindmap");
+    // upsert 覆盖
+    save_canvas_prefs_inner(&db, sid, "straight", false, "org").expect("覆盖");
+    let p2 = get_canvas_prefs_inner(&db, sid).expect("读").expect("有");
+    assert_eq!((p2.edge_style.as_str(), p2.edge_arrows, p2.layout_algorithm.as_str()), ("straight", false, "org"));
+}
+
+#[test]
+fn canvas_prefs_rejects_unknown_enum_and_system() {
+    // Arrange
+    let db = mem_db();
+    let sid = make_global(&db);
+    // Act/Assert：非法连线/布局枚举拒绝（白名单前后端同口径）
+    assert!(save_canvas_prefs_inner(&db, sid, "curvy", false, "radial").is_err());
+    assert!(save_canvas_prefs_inner(&db, sid, "smoothstep", false, "force").is_err());
+    assert!(save_canvas_prefs_inner(&db, sid, "", false, "").is_err());
+    // 不存在的体系（save/get 都拒绝）
+    assert!(save_canvas_prefs_inner(&db, 99999, "straight", false, "radial").is_err());
+    assert!(get_canvas_prefs_inner(&db, 99999).is_err());
+    // 非法 id 拒绝
+    assert!(save_canvas_prefs_inner(&db, 0, "straight", false, "radial").is_err());
+}
+
+#[test]
+fn canvas_prefs_whitelist_all_valid_values() {
+    // Arrange：合法枚举全套逐一试（防白名单漏项——前端枚举同口径）
+    let db = mem_db();
+    let sid = make_global(&db);
+    for style in ["straight", "bezier", "smoothstep", "step"] {
+        for algo in ["radial", "mindmap", "treeRight", "org", "fishbone", "dualRing"] {
+            save_canvas_prefs_inner(&db, sid, style, false, algo).expect("合法保存");
+            let p = get_canvas_prefs_inner(&db, sid).expect("读").expect("有");
+            assert_eq!(p.edge_style, style);
+            assert_eq!(p.layout_algorithm, algo);
+        }
+    }
+}

app/src-tauri/src/db_knowledge_canvas.rs

@@ -14,6 +14,7 @@ use rusqlite::params;
 
 use crate::db::Db;
 use crate::error::Result;
+use crate::types::CanvasPrefs;
 
 impl Db {
     /// 保存单个节点画布位置（拖拽落点；幂等覆盖；节点不存在返回 false）。
@@ -82,6 +83,52 @@ impl Db {
             Ok(true)
         })
     }
+
+    /// 读取体系画布偏好（v0.14.1；从未保存返回 None——前端回落默认值）。
+    ///
+    /// @ai-context: 与视口同表（states 1:1），但行可能先由视口写入而偏好列落
+    ///              DEFAULT——视口与偏好独立读写互不覆盖。
+    pub fn get_canvas_prefs(&self, system_id: i64) -> Result<Option<CanvasPrefs>> {
+        self.with_conn(|conn| {
+            let mut stmt = conn.prepare(
+                "SELECT edge_style, edge_arrows, layout_algorithm FROM knowledge_canvas_states WHERE system_id = ?1",
+            )?;
+            let mut rows = stmt.query_map(params![system_id], |row| {
+                Ok(CanvasPrefs {
+                    edge_style: row.get(0)?,
+                    edge_arrows: row.get::<_, i64>(1)? != 0,
+                    layout_algorithm: row.get(2)?,
+                })
+            })?;
+            match rows.next() {
+                Some(Ok(v)) => Ok(Some(v)),
+                Some(Err(e)) => Err(e.into()),
+                None => Ok(None),
+            }
+        })
+    }
+
+    /// 保存体系画布偏好（upsert——只更新偏好列，视口列保持不动）。
+    ///
+    /// @ai-context: 与 save_canvas_viewport 同 ON CONFLICT(system_id) 模式；枚举
+    ///              合法性校验在 command 层（白名单前后端同口径）——本层只落库。
+    pub fn save_canvas_prefs(
+        &self,
+        system_id: i64,
+        edge_style: &str,
+        edge_arrows: bool,
+        layout_algorithm: &str,
+    ) -> Result<bool> {
+        self.with_conn(|conn| {
+            conn.execute(
+                "INSERT INTO knowledge_canvas_states (system_id, edge_style, edge_arrows, layout_algorithm)
+                 VALUES (?1, ?2, ?3, ?4)
+                 ON CONFLICT(system_id) DO UPDATE SET edge_style = ?2, edge_arrows = ?3, layout_algorithm = ?4",
+                params![system_id, edge_style, edge_arrows, layout_algorithm],
+            )?;
+            Ok(true)
+        })
+    }
 }
 
 /// 命令层单测独立文件（保持本文件 ≤300 行，AGENTS.md §3）。