feat(sessions): notes.session_id 关联与批量转笔记命令

Author: Aparencia

app/src-tauri/src/commands.rs

@@ -169,6 +169,7 @@ pub async fn save_draft_as_note(state: State<'_, AppState>, draft: NoteDraft) ->
         title: normalize_title(draft.title, "未命名笔记"),
         content: truncate_chars(draft.markdown, CONTENT_MAX_CHARS),
         source: "classroom".to_string(),
+        session_id: None,
     };
     state.db.create_note(&new).map_err(|e| e.to_string())
 }
@@ -233,6 +234,7 @@ pub async fn process_to_note(
             title: draft.title.clone(),
             content: draft.markdown.clone(),
             source: "classroom".to_string(),
+            session_id: None,
         })
         .map_err(|e| e.to_string())
     })
@@ -247,6 +249,8 @@ pub async fn create_note(state: State<'_, AppState>, new: NewNote) -> Result<Not
         title: normalize_title(new.title, "未命名笔记"),
         content: truncate_chars(new.content, CONTENT_MAX_CHARS),
         source: if new.source == "classroom" { "classroom" } else { "manual" }.to_string(),
+        // 手动新建笔记无来源会话（session_id 仅由会话→笔记链路写入）
+        session_id: None,
     };
     state.db.create_note(&new).map_err(|e| e.to_string())
 }

app/src-tauri/src/commands_artifacts.rs

@@ -94,6 +94,8 @@ pub async fn artifact_to_note(
             title: title.chars().take(100).collect(),
             content: markdown.chars().take(200_000).collect(),
             source: "classroom".to_string(),
+            // v0.7.1：产物→笔记同样建立会话关联（列表 has_note 标记口径统一）
+            session_id: Some(session_id),
         })
         .map_err(|e| e.to_string())
 }

app/src-tauri/src/commands_session.rs

@@ -7,16 +7,20 @@
 //!              preview_session_note（只读预览）共用 note_filter 单一管线——
 //!              输出一致性由构造保证（同一过滤链/同一 Markdown 组装）。
 
+use std::collections::HashSet;
+
 use tauri::State;
 
 use crate::ai_protocol::TextFilterDecision;
 use crate::commands::{normalize_title, AppState, TITLE_MAX_CHARS};
+use crate::db::Db;
 use crate::db_sessions::SESSION_STATUS_RECORDING;
 use crate::note_filter::{apply_ai_decisions, filter_note, NoteFilterResult};
 use crate::types::{
-    NewNote, NewSession, NewSessionOcrBlock, NewSessionSegment, Note, Session, SessionDetail,
-    SessionOcrBlock, SessionSegment,
+    BatchNoteResult, ConvertedNote, NewNote, NewSession, NewSessionOcrBlock, NewSessionSegment,
+    Note, Session, SessionDetail, SessionListItem, SessionOcrBlock, SessionSegment, SkippedNote,
 };
+use crate::ui_junk::UiJunkList;
 
 /// 会话列表单页上限。
 const LIST_LIMIT_MAX: u64 = 200;
@@ -46,14 +50,14 @@ pub async fn finish_session(state: State<'_, AppState>, id: i64) -> Result<bool,
     state.db.finish_session(id).map_err(|e| e.to_string())
 }
 
-/// 列出会话（关键词可选；默认第 1 页 50 条，新→旧）。
+/// 列出会话（关键词可选；默认第 1 页 50 条，新→旧；v0.7.1 起携带转化状态标记）。
 #[tauri::command]
 pub async fn list_sessions(
     state: State<'_, AppState>,
     keyword: Option<String>,
     limit: Option<u64>,
     offset: Option<u64>,
-) -> Result<Vec<Session>, String> {
+) -> Result<Vec<SessionListItem>, String> {
     let limit = limit.unwrap_or(50).min(LIST_LIMIT_MAX);
     state
         .db
@@ -145,53 +149,131 @@ pub async fn add_session_ocr_block(
 
 /// 加载会话笔记原料（会话 + 转写段 + OCR 块；单一管线双出口共用）。
 ///
-/// @ai-context: REQ-081：预览与转笔记从同一原料装载开始，保证口径一致。
+/// @ai-context: REQ-081：预览与转笔记从同一原料装载开始，保证口径一致；
+///              v0.7.1 起注入 &Db（不再依赖 AppState）——批量编排可单测。
 fn load_note_material(
-    state: &AppState,
+    db: &Db,
     id: i64,
 ) -> Result<(Session, Vec<SessionSegment>, Vec<SessionOcrBlock>), String> {
     if id <= 0 {
         return Err("无效的会话 id".to_string());
     }
-    let session = state
-        .db
+    let session = db
         .get_session(id)
         .map_err(|e| e.to_string())?
         .ok_or_else(|| format!("会话不存在: {}", id))?;
     if session.status == SESSION_STATUS_RECORDING {
         return Err("进行中的会话不能生成笔记，请先结束会话".to_string());
     }
-    let segments = state.db.list_segments(id).map_err(|e| e.to_string())?;
-    let ocr_blocks = state.db.list_ocr_blocks(id).map_err(|e| e.to_string())?;
+    let segments = db.list_segments(id).map_err(|e| e.to_string())?;
+    let ocr_blocks = db.list_ocr_blocks(id).map_err(|e| e.to_string())?;
     Ok((session, segments, ocr_blocks))
 }
 
-/// 会话 → 笔记：转写段 + OCR 块经 note_filter 净化管线，一键落库（REQ-010 闭环）。
+/// 会话 → 笔记核心（v0.7.1 提取：单条与批量共用同一管线）。
 ///
 /// @ai-context: REQ-082：过滤链（UI 垃圾/重复合并/碎片/低置信）与预览共用；
 ///              ai_decisions（REQ-085）可选叠加——前端把预览中已确认的 AI
 ///              判定结果回传，落库与预览输出保持一致（默认 None=纯规则）。
-/// @ai-context: 只允许 finished/failed 会话转换；source 沿用 classroom。
-#[tauri::command]
-pub async fn session_to_note(
-    state: State<'_, AppState>,
+/// @ai-context: 只允许 finished/failed 会话转换；source 沿用 classroom；
+///              v0.7.1 起落库携带 session_id（列表 has_note/查看笔记跳转的数据源）。
+fn convert_to_note(
+    db: &Db,
+    ui_junk: &UiJunkList,
     id: i64,
     title: Option<String>,
     ai_decisions: Option<Vec<TextFilterDecision>>,
 ) -> Result<Note, String> {
-    let (session, segments, ocr_blocks) = load_note_material(&state, id)?;
+    let (session, segments, ocr_blocks) = load_note_material(db, id)?;
     let fallback = format!("{}（会话）", session.title);
     let title = normalize_title(title.unwrap_or_default(), &fallback);
-    let mut result = filter_note(&title, &segments, &ocr_blocks, &state.ui_junk);
+    let mut result = filter_note(&title, &segments, &ocr_blocks, ui_junk);
     if let Some(decisions) = ai_decisions {
         result = apply_ai_decisions(result, &decisions);
     }
     let new = NewNote {
         title: result.title.clone(),
         content: result.markdown.clone(),
         source: "classroom".to_string(),
+        session_id: Some(id),
     };
-    state.db.create_note(&new).map_err(|e| e.to_string())
+    db.create_note(&new).map_err(|e| e.to_string())
+}
+
+/// 会话 → 笔记：转写段 + OCR 块经 note_filter 净化管线，一键落库（REQ-010 闭环）。
+#[tauri::command]
+pub async fn session_to_note(
+    state: State<'_, AppState>,
+    id: i64,
+    title: Option<String>,
+    ai_decisions: Option<Vec<TextFilterDecision>>,
+) -> Result<Note, String> {
+    convert_to_note(&state.db, &state.ui_junk, id, title, ai_decisions)
+}
+
+/// 批量转笔记核心编排（v0.7.1：部分成功语义——单条失败不阻塞其他）。
+///
+/// @ai-context: 纯编排纯函数（注入 Db + UiJunkList，无 Tauri 依赖，可单测）；
+///              跳过规则显式回传原因（不静默）：无效 id / 进行中 / 已转 / 会话不存在；
+///              DB 读错误视为硬失败中止（库损坏时继续处理无意义）。
+pub fn run_batch_conversion(
+    db: &Db,
+    ui_junk: &UiJunkList,
+    ids: Vec<i64>,
+) -> Result<BatchNoteResult, String> {
+    if ids.len() > 50 {
+        return Err("批量转换上限 50 条".to_string());
+    }
+    let mut converted = Vec::new();
+    let mut skipped = Vec::new();
+    let mut seen = HashSet::new();
+    for id in ids {
+        if id <= 0 {
+            skipped.push(SkippedNote { session_id: id, reason: "无效的会话 id".to_string() });
+            continue;
+        }
+        if !seen.insert(id) {
+            continue; // 重复 id 静默去重（同一会话只处理一次）
+        }
+        match db.get_session(id) {
+            Ok(Some(s)) if s.status == SESSION_STATUS_RECORDING => {
+                skipped.push(SkippedNote {
+                    session_id: id,
+                    reason: "进行中的会话不能生成笔记".to_string(),
+                });
+            }
+            Ok(Some(_)) => {
+                // 已转跳过（防重复笔记）；详情页单条转换保留"有意重新生成"路径
+                if db.find_note_by_session(id).map_err(|e| e.to_string())?.is_some() {
+                    skipped.push(SkippedNote {
+                        session_id: id,
+                        reason: "已转笔记（批量转跳过，避免重复）".to_string(),
+                    });
+                    continue;
+                }
+                match convert_to_note(db, ui_junk, id, None, None) {
+                    Ok(note) => converted.push(ConvertedNote { session_id: id, note_id: note.id }),
+                    Err(reason) => skipped.push(SkippedNote { session_id: id, reason }),
+                }
+            }
+            Ok(None) => {
+                skipped.push(SkippedNote { session_id: id, reason: "会话不存在".to_string() });
+            }
+            Err(e) => {
+                skipped.push(SkippedNote { session_id: id, reason: e.to_string() });
+            }
+        }
+    }
+    Ok(BatchNoteResult { converted, skipped })
+}
+
+/// 批量转笔记（v0.7.1 会话体验：列表勾选批量转化）。
+#[tauri::command]
+pub async fn batch_session_to_note(
+    state: State<'_, AppState>,
+    ids: Vec<i64>,
+) -> Result<BatchNoteResult, String> {
+    run_batch_conversion(&state.db, &state.ui_junk, ids)
 }
 
 /// 会话笔记预览（REQ-081）：过滤后只读预览——不落库、不改库。
@@ -204,7 +286,7 @@ pub async fn preview_session_note(
     state: State<'_, AppState>,
     id: i64,
 ) -> Result<NoteFilterResult, String> {
-    let (session, segments, ocr_blocks) = load_note_material(&state, id)?;
+    let (session, segments, ocr_blocks) = load_note_material(&state.db, id)?;
     Ok(filter_note(&session.title, &segments, &ocr_blocks, &state.ui_junk))
 }
 
@@ -278,12 +360,12 @@ fn is_cjk_num(c: char) -> bool {
     "零〇一二三四五六七八九十百".contains(c)
 }
 
-/// 课程分组（会话列表按课程键分组，组内新→旧）。
+/// 课程分组（会话列表按课程键分组，组内新→旧；v0.7.1：组内携带转化状态标记）。
 #[derive(Debug, Clone, serde::Serialize)]
 #[serde(rename_all = "camelCase")]
 pub struct CourseGroup {
     pub course: String,
-    pub sessions: Vec<Session>,
+    pub sessions: Vec<SessionListItem>,
 }
 
 /// 会话列表按课程分组（REQ-078：长列表可折叠）。
@@ -293,9 +375,10 @@ pub async fn list_session_courses(state: State<'_, AppState>) -> Result<Vec<Cour
         .db
         .list_sessions(None, LIST_LIMIT_MAX, 0)
         .map_err(|e| e.to_string())?;
-    let mut groups: std::collections::BTreeMap<String, Vec<Session>> = std::collections::BTreeMap::new();
+    let mut groups: std::collections::BTreeMap<String, Vec<SessionListItem>> =
+        std::collections::BTreeMap::new();
     for s in sessions {
-        groups.entry(course_of(&s.title)).or_default().push(s);
+        groups.entry(course_of(&s.session.title)).or_default().push(s);
     }
     Ok(groups
         .into_iter()
@@ -329,7 +412,8 @@ pub async fn search_session_segments(
         return Ok(Vec::new());
     }
     let mut hits = Vec::new();
-    for session in state.db.list_sessions(None, LIST_LIMIT_MAX, 0).map_err(|e| e.to_string())? {
+    for item in state.db.list_sessions(None, LIST_LIMIT_MAX, 0).map_err(|e| e.to_string())? {
+        let session = &item.session;
         for s in state.db.list_segments(session.id).map_err(|e| e.to_string())? {
             if s.text.to_lowercase().contains(&kw) {
                 hits.push(SegmentHit {
@@ -384,3 +468,8 @@ fn snippet_around(text: &str, kw_lower: &str) -> String {
     }
     snippet
 }
+
+/// 批量转笔记单测独立文件（保持本文件 ≤300 行目标，AGENTS.md §3）。
+#[cfg(test)]
+#[path = "commands_session_batch_tests.rs"]
+mod batch_tests;