//! 笔记模块 Tauri 命令层。 //! //! 所有库操作都经 [`super::library`] 的路径安全校验、所有库外文件操作都经 //! [`super::files`] 的授权白名单、所有 WebDAV 操作都经 [`super::webdav`] 的会话层; //! 命令本身只做几件事:解析当前库根 → 调下层 → 标记「本应用刚写过」→ 发事件。 //! //! # 为什么每条命令都要先 `retarget` //! //! 索引服务是常驻 worker,它记着「自己挂在哪个库根上」。库根可以在设置里改, //! 而 worker 不知道这件事 —— 若命令层不主动告知,就会出现「侧栏显示新库、 //! 搜索却在新库的旧索引里查」这种最难查的错。`retarget` 在库根未变时是两次 //! 比较,成本可忽略。 //! //! # 网络类命令为什么是异步的 //! //! `tests_webdav` / `sync_now` / `backup_now` 会真的发 HTTP 请求(同步一个几百篇的 //! 库可能跑几分钟)。Tauri 的同步命令会占住调用线程,因此这几个一律 `async` 并用 //! `spawn_blocking` 把阻塞的 reqwest 调用挪到专用线程池 —— 既不卡 UI,也不卡 //! Tauri 的命令线程池。 use std::path::PathBuf; use tauri::{AppHandle, Emitter, State}; use super::backup; use super::export; use super::files; use super::import; use super::index::{ NoteBacklinks, NoteIndexStats, NoteSearchHit, NoteSearchPage, NoteSearchQuery, }; use super::index_service::{self, IndexService, NoteIndexReport}; use super::library; use super::templates::{self, NoteTemplate}; use super::types::{ BackupReport, BackupSnapshot, ImportReport, LibraryEntry, LibraryInfo, NoteDoc, EditorSettings, SyncProgress, }; use super::webdav::{self, WebdavTestResult}; use super::EditorManager; use crate::constants::events; /// 通知各窗口「库内容已变更」(新建/保存/重命名/删除/切换库根后)。 fn emit_library_changed(app: &AppHandle) { if let Err(e) = app.emit(events::EDITOR_LIBRARY_CHANGED, ()) { crate::logger::log_warn("editor", &format!("发出库变更事件失败: {e}")); } } /// 通知各窗口「设置已变更」(跨窗口同步,范式同 terminal-settings)。 fn emit_settings_changed(app: &AppHandle) { if let Err(e) = app.emit(events::EDITOR_SETTINGS, ()) { crate::logger::log_warn("editor", &format!("发出设置变更事件失败: {e}")); } } /// 当前库根(按设置解析),并确保目录存在。 fn current_root(state: &EditorManager) -> PathBuf { let settings = state.load_settings(); library::resolve_library_root(state.module_dir(), &settings) } /// 取索引服务并把它的库根对齐到当前设置。 fn indexed<'a>(app: &AppHandle, state: &EditorManager) -> Result<&'a IndexService, String> { let root = current_root(state); let service = index_service::service(app); service.retarget(root)?; Ok(service) } /// 组装库状态概览。 fn library_info(state: &EditorManager) -> Result { let settings = state.load_settings(); let root = library::resolve_library_root(state.module_dir(), &settings); library::ensure_library(&root)?; let entries = library::scan(&root)?; Ok(LibraryInfo { root: root.to_string_lossy().to_string(), is_custom: settings .library_root .as_deref() .map(|s| !s.trim().is_empty()) .unwrap_or(false), note_count: library::count_notes(&entries), }) } /// 标记「本应用刚**批量**写过」,随后把库同步进索引。 /// /// 用于导入 / WebDAV 同步 / 恢复 / 模板导出这类**无法逐路径枚举**的操作:写完之后 /// 在抑制窗口内的一切文件事件都当作自己写的。 /// /// 顺序重要:先标记(抑制窗口从写入那一刻算起),再同步。这里走全库增量同步而不是 /// 「只索引这一篇」的快路径:单文件快路径要额外拼一份 wikilink 的 `stems` 映射, /// 而不完整的映射会让 `[[某笔记]]` 解析到错误位置;全量同步靠 (mtime,size) 跳过 /// 未变文件,万篇规模也是毫秒级,用一点开销换「索引永远自洽」。 fn mark_written_then_index(app: &AppHandle, state: &EditorManager) { match indexed(app, state) { Ok(service) => { service.mark_write_all(); if let Err(e) = service.sync() { crate::logger::log_warn("editor", &format!("保存后同步索引失败: {e}")); } } Err(e) => crate::logger::log_warn("editor", &format!("索引服务不可用: {e}")), } } /// 写入前登记「本应用即将写这一篇笔记」(按库内相对路径)。 /// /// **必须在 `library::write_note` 之前调用**:notify 的 Modify 事件可能与写入几乎 /// 同时到达索引 worker,晚于写盘再登记就会漏过 —— 前端便会把自家的保存当成 /// 「外部修改」,进而重载文档、把光标弹回第一行。 fn mark_pending_note_write(app: &AppHandle, state: &EditorManager, rel_path: &str) { match indexed(app, state) { Ok(service) => service.mark_write_path(rel_path), Err(e) => crate::logger::log_warn("editor", &format!("索引服务不可用: {e}")), } } /// 把库同步进索引(不登记自我写入 —— 调用方已在写入前按路径登记过)。 fn sync_index_after_write(app: &AppHandle, state: &EditorManager) { match indexed(app, state) { Ok(service) => { if let Err(e) = service.sync() { crate::logger::log_warn("editor", &format!("保存后同步索引失败: {e}")); } } Err(e) => crate::logger::log_warn("editor", &format!("索引服务不可用: {e}")), } } // ===== 设置与库 ===== /// 读取笔记模块设置。 #[tauri::command] #[specta::specta] pub fn editor_get_settings(state: State<'_, EditorManager>) -> Result { Ok(state.load_settings()) } /// 临时草稿文件的存放目录(`{app_data_dir}/editor/scratch`),不存在则创建,返回绝对路径。 /// /// 「新建临时文件(草稿)」用它:**不随应用退出删除** —— 用户可能还没决定存哪儿, /// 收尾交给「关闭该文件时选择保存 / 删除」。 /// /// # 为什么不放在**安装目录** /// /// 安装目录(`Program Files` 之类)对普通用户通常不可写,装到系统盘就必然失败; /// 而 `app_data_dir` 本来就是本模块放设置与默认库的地方,是「应用自己的可写目录」的 /// 标准位置,且卸载时随程序数据一起清理。 #[tauri::command] #[specta::specta] pub fn editor_scratch_dir(state: State<'_, EditorManager>) -> Result { let dir = state.module_dir().join("scratch"); std::fs::create_dir_all(&dir).map_err(|e| format!("创建临时目录失败:{e}"))?; Ok(dir.to_string_lossy().to_string()) } /// 保存笔记模块设置(自愈后落盘,并广播给各窗口)。 #[tauri::command] #[specta::specta] pub fn editor_save_settings( app: AppHandle, state: State<'_, EditorManager>, settings: EditorSettings, ) -> Result { let mut next = settings; next.heal(); state.save_settings(&next)?; // 全局快捷键可能刚被改了:就地重注册(`register_shortcut` 会先注销本模块的旧键, // 因此「清空快捷键」也能通过传空串生效) state.init_on_launch(&app); emit_settings_changed(&app); Ok(next) } /// 当前库状态概览(库根 / 是否自定义 / 笔记数)。 #[tauri::command] #[specta::specta] pub fn editor_library_info(state: State<'_, EditorManager>) -> Result { library_info(&state) } /// 设置库根(`None` 或空串 = 恢复默认库根)。 #[tauri::command] #[specta::specta] pub fn editor_set_library_root( app: AppHandle, state: State<'_, EditorManager>, root: Option, ) -> Result { let cleaned = root.and_then(|r| { let trimmed = r.trim().to_string(); if trimmed.is_empty() { None } else { Some(trimmed) } }); if let Some(path) = &cleaned { let p = std::path::Path::new(path); if !p.exists() { return Err(format!("目录不存在:{path}")); } if !p.is_dir() { return Err("请选择一个文件夹作为笔记库".to_string()); } } let mut settings = state.load_settings(); settings.library_root = cleaned; state.save_settings(&settings)?; emit_settings_changed(&app); let info = library_info(&state)?; emit_library_changed(&app); Ok(info) } /// 扫描库,返回扁平条目列表(前端组树)。 #[tauri::command] #[specta::specta] pub fn editor_scan_library(state: State<'_, EditorManager>) -> Result, String> { let root = current_root(&state); library::ensure_library(&root)?; library::scan(&root) } /// 读取一篇笔记。 #[tauri::command] #[specta::specta] pub fn editor_read_note(state: State<'_, EditorManager>, rel_path: String) -> Result { let root = current_root(&state); library::read_note(&root, &rel_path) } /// 保存一篇笔记(写完立即更新索引,使搜索无需等下一轮全量同步)。 #[tauri::command] #[specta::specta] pub fn editor_save_note( app: AppHandle, state: State<'_, EditorManager>, rel_path: String, content: String, ) -> Result { let root = current_root(&state); // 先登记「即将写这一篇」,再落盘:notify 的事件可能与写入同时抵达 worker mark_pending_note_write(&app, &state, &rel_path); let doc = library::write_note(&root, &rel_path, &content)?; sync_index_after_write(&app, &state); emit_library_changed(&app); Ok(doc) } /// 新建笔记(自动补 `.md`、重名加序号),返回新文档。 /// /// `template_id` 为空时用默认模板;找不到该模板时同样回退默认模板(不报错 —— /// 模板文件被删掉不该让「新建笔记」这个核心动作失败)。 #[tauri::command] #[specta::specta] pub fn editor_create_note( app: AppHandle, state: State<'_, EditorManager>, dir_rel: String, name: String, template_id: Option, ) -> Result { let root = current_root(&state); let template = template_id.unwrap_or_default(); // 模板为空时走「不读模板目录」的那条路径:模板目录被删/损坏也要能新建笔记 let doc = if template.trim().is_empty() { library::create_note(&root, &dir_rel, &name)? } else { library::create_note_with_template(&root, &dir_rel, &name, &template)? }; mark_written_then_index(&app, &state); emit_library_changed(&app); Ok(doc) } /// 打开(或创建)今天的日记:`日记/YYYY-MM-DD.md`。 #[tauri::command] #[specta::specta] pub fn editor_daily_note(app: AppHandle, state: State<'_, EditorManager>) -> Result { let root = current_root(&state); let name = templates::daily_note_name(); let dir = "日记"; let rel = format!("{dir}/{name}.md"); let path = library::safe_join(&root, &rel)?; let doc = if path.is_file() { library::read_note(&root, &rel)? } else { // 日记用同名内置模板;没有则回退默认(模板可被用户改名,这里不能假定存在) let template = if templates::body_of(&root, "builtin:日记").is_some() { "builtin:日记" } else { "" }; library::create_note_with_template(&root, dir, &name, template)? }; mark_written_then_index(&app, &state); emit_library_changed(&app); Ok(doc) } /// 新建文件夹。 #[tauri::command] #[specta::specta] pub fn editor_create_folder( app: AppHandle, state: State<'_, EditorManager>, dir_rel: String, name: String, ) -> Result<(), String> { let root = current_root(&state); library::create_folder(&root, &dir_rel, &name)?; emit_library_changed(&app); Ok(()) } /// 重命名条目,返回新相对路径。 #[tauri::command] #[specta::specta] pub fn editor_rename_entry( app: AppHandle, state: State<'_, EditorManager>, rel_path: String, new_name: String, ) -> Result { let root = current_root(&state); let next = library::rename_entry(&root, &rel_path, &new_name)?; // 改名在索引里是「旧路径消失 + 新路径出现」:增量同步一次比手工删+插更稳 if let Ok(service) = indexed(&app, &state) { if let Err(e) = service.sync() { crate::logger::log_warn("editor", &format!("改名后同步索引失败: {e}")); } } emit_library_changed(&app); Ok(next) } /// 删除条目(目录递归删除)。 #[tauri::command] #[specta::specta] pub fn editor_delete_entry( app: AppHandle, state: State<'_, EditorManager>, rel_path: String, ) -> Result<(), String> { let root = current_root(&state); library::delete_entry(&root, &rel_path)?; if let Ok(service) = indexed(&app, &state) { if let Err(e) = service.sync() { crate::logger::log_warn("editor", &format!("删除后同步索引失败: {e}")); } } emit_library_changed(&app); Ok(()) } // ===== 索引与检索 ===== /// 全量重建索引(设置页「重建索引」)。文件不受影响。 #[tauri::command] #[specta::specta] pub fn editor_rebuild_index( app: AppHandle, state: State<'_, EditorManager>, ) -> Result { let service = indexed(&app, &state)?; let report = service.rebuild()?; Ok(finish_report(service, report)) } /// 增量同步索引(打开编辑器 / 手动刷新时调用)。 #[tauri::command] #[specta::specta] pub fn editor_sync_index( app: AppHandle, state: State<'_, EditorManager>, ) -> Result { let service = indexed(&app, &state)?; let report = service.sync()?; Ok(finish_report(service, report)) } /// 把同步结果补上「索引里的笔记数」再回传(前端省一次 stats 往返)。 fn finish_report(service: &IndexService, report: super::index::NoteSyncReport) -> NoteIndexReport { let note_count = service.stats().map(|s| s.note_count).unwrap_or(0); let mut out: NoteIndexReport = report.into(); out.note_count = note_count; out } /// 全文检索 / 按标签 / 按目录筛选。 #[tauri::command] #[specta::specta] pub fn editor_search_notes( app: AppHandle, state: State<'_, EditorManager>, query: NoteSearchQuery, ) -> Result { let service = indexed(&app, &state)?; service.search(query) } /// 快速打开清单(`Ctrl+P`;只取路径/标题,带全文片段反而会拖慢输入响应)。 #[tauri::command] #[specta::specta] pub fn editor_list_notes( app: AppHandle, state: State<'_, EditorManager>, limit: Option, ) -> Result, String> { let service = indexed(&app, &state)?; service.list(limit.unwrap_or(500)) } /// 标签及计数。 #[tauri::command] #[specta::specta] pub fn editor_tags( app: AppHandle, state: State<'_, EditorManager>, ) -> Result, String> { let service = indexed(&app, &state)?; service.tags() } /// 一篇笔记的链接关系(出链 + 入链)。 #[tauri::command] #[specta::specta] pub fn editor_backlinks( app: AppHandle, state: State<'_, EditorManager>, rel_path: String, ) -> Result { let service = indexed(&app, &state)?; service.backlinks(&rel_path) } /// 全库链接图(已解析的内部链接边)。 #[tauri::command] #[specta::specta] pub fn editor_link_graph( app: AppHandle, state: State<'_, EditorManager>, ) -> Result, String> { let service = indexed(&app, &state)?; let edges = service.link_graph()?; Ok(edges .into_iter() .map(|(from, to)| LinkEdge { from, to }) .collect()) } /// 链接图的一条边(用 `from`/`to` 而不是元组:元组序列化成数组后前端得按下标取值, /// 改一次顺序就静默错位 —— 与 `terminal/history.rs` 的 `HistorySource` 同一理由)。 #[derive(Debug, Clone, serde::Serialize, specta::Type)] #[serde(rename_all = "camelCase")] pub struct LinkEdge { pub from: String, pub to: String, } /// 索引状态(设置页展示:索引数 / 文件数 / 标签数 / 索引文件路径)。 #[tauri::command] #[specta::specta] pub fn editor_index_stats( app: AppHandle, state: State<'_, EditorManager>, ) -> Result { let service = indexed(&app, &state)?; service.stats() } // ===== 库外任意文件 ===== /// 把库内图片读成 `data:` URL(供编辑器内联预览)。 /// /// # 为什么走 data URL 而不是 asset 协议 /// /// 库根是用户自选目录,可以用 `convertFileSrc` + `assetProtocol.scope` 直接把磁盘路径 /// 交给 ``。但那条路要求把「用户选的任意目录」加进 asset 协议的作用域白名单 —— /// 那等于给 WebView 开一个「可以按路径读任意文件」的口子,而笔记模块的整个安全模型 /// 是「库根沙箱 + 授权白名单」。走 data URL 则完全在既有沙箱内:路径必须经 /// [`library::safe_join`](拒绝 `..` 与绝对路径),且只认图片扩展名。 /// /// # 为什么必须有大小上限 /// /// data URL 是 base64,体积约为原文件的 1.34 倍,且会进 JS 堆。一张 20MB 的图片 /// 变成 27MB 字符串,多预览几张就能把 WebView 拖垮。超限时**不报错**,返回 /// `None` —— 调用方(编辑器)会把该图片节点当作普通文本渲染,用户看到的就是 /// 原始 Markdown,不会打断编辑。 const MAX_ASSET_BYTES: u64 = 8 * 1024 * 1024; #[tauri::command] #[specta::specta] pub fn editor_read_asset( state: State<'_, EditorManager>, rel_path: String, ) -> Result, String> { let root = current_root(&state); let path = library::safe_join(&root, &rel_path)?; if !path.is_file() { return Ok(None); } let ext = path .extension() .map(|e| e.to_string_lossy().to_ascii_lowercase()) .unwrap_or_default(); let mime = match ext.as_str() { "png" => "image/png", "jpg" | "jpeg" => "image/jpeg", "gif" => "image/gif", "webp" => "image/webp", "svg" => "image/svg+xml", "bmp" => "image/bmp", "avif" => "image/avif", // 非图片(或未识别):不预览。返回 `None` 而不是报错 —— 正文里写个 // `![](../notes.md)` 不该让编辑器弹错误。 _ => return Ok(None), }; let meta = std::fs::metadata(&path).map_err(|e| format!("读取附件信息失败: {e}"))?; if meta.len() > MAX_ASSET_BYTES { crate::logger::log_info( "editor", &format!("附件过大,跳过内联预览:{rel_path}({} 字节)", meta.len()), ); return Ok(None); } use base64::Engine; let bytes = std::fs::read(&path).map_err(|e| format!("读取附件失败: {e}"))?; let encoded = base64::engine::general_purpose::STANDARD.encode(&bytes); Ok(Some(format!("data:{mime};base64,{encoded}"))) } /// 取出「启动时命令行 / 文件关联指定的文件」(取走即清空)。 /// /// 前端在注册完事件监听后调用。**不能靠启动时 `emit`** —— 那时 WebView 还没加载完, /// 事件会直接丢掉(见 `editor/args.rs` 的 `PENDING` 注释)。 #[tauri::command] #[specta::specta] pub fn editor_take_pending_file() -> Result, String> { Ok(super::args::take_pending_target()) } /// 打开(读取)库外任意文件。 /// /// 读取本身不要求预先授权(用户可能刚通过系统对话框选完,也可能带命令行参数), /// 但**读取会顺带登记授权** —— 于是「打开过就能保存」这条最符合直觉的规则成立。 #[tauri::command] #[specta::specta] pub fn editor_open_file( state: State<'_, EditorManager>, path: String, ) -> Result { let settings = state.load_settings(); index_service::read_and_authorize(&path, settings.max_file_size_mb) } /// 保存库外任意文件(按前端回传的编码与换行写回)。 #[tauri::command] #[specta::specta] pub fn editor_write_file( app: AppHandle, state: State<'_, EditorManager>, path: String, content: String, encoding: String, eol: String, ) -> Result { let settings = state.load_settings(); let doc = files::write_file(&path, &content, &encoding, &eol, settings.max_file_size_mb)?; if let Ok(service) = indexed(&app, &state) { // 库外文件的路径语义与库内相对路径不同,这里退回窗口式抑制; // 真正在库内的 `.md`(被当作普通文件打开)同样受这一窗口保护。 service.mark_write_all(); } Ok(doc) } /// 以指定编码重新解码磁盘字节(切换编码用;不写回,只换一种解释方式)。 #[tauri::command] #[specta::specta] pub fn editor_redecode_file( state: State<'_, EditorManager>, path: String, encoding: String, ) -> Result { let settings = state.load_settings(); files::redecode_file(&path, &encoding, settings.max_file_size_mb) } /// 显式登记一个路径为「可写」。 /// /// 前端在拿到系统对话框返回的路径后调用(那种路径不经过 `editor_open_file`, /// 但用户确实是用系统对话框选的,属于「用户显式选择」)。 #[tauri::command] #[specta::specta] pub fn editor_authorize_file(path: String) -> Result<(), String> { if path.trim().is_empty() { return Err("路径为空".to_string()); } files::authorize(std::path::Path::new(path.trim())); Ok(()) } /// 把 base64 图片写进库根的 `assets/`,返回可插入 Markdown 的相对路径。 /// /// 为什么走 base64 而不是直接给前端一个写文件句柄:粘贴的图片来自剪贴板, /// 前端拿到的本来就是 Blob/DataURL;转一次 base64 比让前端拿到「任意写权限」 /// 安全得多(写的位置由后端决定,且只落在 `assets/`)。 #[tauri::command] #[specta::specta] pub fn editor_write_asset( state: State<'_, EditorManager>, file_name: String, ext: String, data_base64: String, ) -> Result { use base64::Engine; let root = current_root(&state); library::ensure_library(&root)?; let data = base64::engine::general_purpose::STANDARD .decode(data_base64.trim()) .map_err(|e| format!("图片数据解析失败: {e}"))?; files::write_asset(&root, &file_name, &data, &ext) } // ===== 模板(P2) ===== /// 列出可用模板(用户模板优先,同名覆盖内置)。 /// /// 顺带确保库内 `templates/` 目录存在 —— 这样界面上「新建模板」按钮第一次点击 /// 就能直接写文件,不需要用户先去资源管理器建目录。 #[tauri::command] #[specta::specta] pub fn editor_list_templates(state: State<'_, EditorManager>) -> Result, String> { let root = current_root(&state); library::ensure_library(&root)?; let _ = templates::ensure_dir(&root); Ok(templates::list(&root)) } /// 把内置模板导出到库内 `templates/`(已存在的不覆盖),返回新写入的名字。 /// /// 三种用法: /// - 都不传:把全部内置模板导出到 `templates/`(用户想改内置模板时的起点); /// - 传 `name` + `body`:新建一个自定义模板。 #[tauri::command] #[specta::specta] pub fn editor_add_template( app: AppHandle, state: State<'_, EditorManager>, name: Option, body: Option, ) -> Result, String> { let root = current_root(&state); let written = match (name, body) { (Some(name), Some(body)) => { let safe = templates::validate_name(&name)?; templates::ensure_dir(&root)?; let path = root.join("templates").join(format!("{safe}.md")); if path.exists() { return Err(format!("模板「{safe}」已存在")); } std::fs::write(&path, body).map_err(|e| format!("写入模板失败: {e}"))?; vec![safe] } // 不带参数 = 导出全部内置模板 _ => templates::export_builtin(&root)?, }; mark_written_then_index(&app, &state); emit_library_changed(&app); Ok(written) } /// 读取一个模板的正文(界面上「查看 / 编辑模板」用)。 /// /// 内置模板也返回正文(便于「另存为自定义模板」),但 `path` 为 `None` —— /// 内置模板没有对应的库内文件,前端据此禁掉「直接编辑」。 #[tauri::command] #[specta::specta] pub fn editor_read_template( state: State<'_, EditorManager>, template_id: String, ) -> Result { let root = current_root(&state); let body = templates::body_of(&root, &template_id) .ok_or_else(|| format!("模板不存在:{template_id}"))?; Ok(TemplateSource { body, path: templates::relative_path(&template_id), }) } /// 模板正文与它在库内的位置(`path` 为 `None` = 内置模板)。 #[derive(Debug, Clone, serde::Serialize, specta::Type)] #[serde(rename_all = "camelCase")] pub struct TemplateSource { pub body: String, pub path: Option, } // ===== 导入 / 导出(P2) ===== /// 从磁盘路径导入(文件 / 目录 / zip 自动判别)。 #[tauri::command] #[specta::specta] pub fn editor_import( app: AppHandle, state: State<'_, EditorManager>, source: String, dest_dir: String, ) -> Result { let root = current_root(&state); let report = import::import_path(&root, &source, &dest_dir)?; mark_written_then_index(&app, &state); emit_library_changed(&app); Ok(report) } /// 把一篇笔记导出为独立 HTML 文件,返回落盘路径。 /// /// HTML 的渲染在**前端**(`markdown-it` + `DOMPurify` 都在前端),这里只负责把 /// 已经渲染好的字符串写到用户选定的位置 —— 即「后端不碰渲染逻辑,前端不碰文件系统」。 #[tauri::command] #[specta::specta] pub fn editor_export_note( state: State<'_, EditorManager>, rel_path: String, html: String, dest: String, ) -> Result { let root = current_root(&state); // 无论导出哪一篇,都要先确认它确实在库内(不接受库外相对路径) library::read_note(&root, &rel_path)?; let target = PathBuf::from(dest.trim()); if target.as_os_str().is_empty() { return Err("请选择导出位置".to_string()); } if let Some(parent) = target.parent() { std::fs::create_dir_all(parent).map_err(|e| format!("创建导出目录失败: {e}"))?; } let bytes = html.into_bytes(); std::fs::write(&target, &bytes).map_err(|e| format!("写入导出文件失败: {e}"))?; crate::logger::log_info( "editor", &format!("导出 {} → {}({} 字节)", rel_path, target.display(), bytes.len()), ); Ok(target.to_string_lossy().to_string()) } /// 把整库(或某个目录)打包成 zip,返回落盘路径。 #[tauri::command] #[specta::specta] pub fn editor_export_zip( state: State<'_, EditorManager>, dest: String, dir_rel: Option, ) -> Result { let root = current_root(&state); let dest_path = PathBuf::from(dest.trim()); if dest_path.as_os_str().is_empty() { return Err("请选择导出位置".to_string()); } let scope = dir_rel.unwrap_or_default(); let (bytes, files) = export::zip_scope(&root, &scope)?; if let Some(parent) = dest_path.parent() { std::fs::create_dir_all(parent).map_err(|e| format!("创建导出目录失败: {e}"))?; } std::fs::write(&dest_path, &bytes).map_err(|e| format!("写入 zip 失败: {e}"))?; crate::logger::log_info( "editor", &format!("导出 zip:{files} 个文件 → {}", dest_path.display()), ); Ok(dest_path.to_string_lossy().to_string()) } /// 把整库打包成一份本地快照 zip(与上传到远端的快照是同一份内容)。 /// /// 与 [`editor_export_zip`] 的区别只在**目的**:导出是「我要把笔记拿走/分享」, /// 快照是「我要一份可整体恢复的备份」。两者目前内容一致,但保留两个入口是因为 /// 将来它们的排除规则可能分化(比如快照要带同步基线,导出不该带)。 #[tauri::command] #[specta::specta] pub fn editor_export_snapshot_local( state: State<'_, EditorManager>, dest: Option, ) -> Result { let root = current_root(&state); library::ensure_library(&root)?; let target = match dest.map(|d| d.trim().to_string()) { Some(d) if !d.is_empty() => PathBuf::from(d), _ => backup::default_snapshot_path(&root), }; backup::snapshot_to_file(&root, &target)?; Ok(target.to_string_lossy().to_string()) } // ===== WebDAV 同步 / 备份(P2) ===== /// 当前 WebDAV 配置状态(设置页展示;**密码只回传「是否已保存」**)。 #[tauri::command] #[specta::specta] pub fn editor_webdav_status(state: State<'_, EditorManager>) -> Result { let settings = state.load_settings(); let has_password = crate::secrets::secret_read(webdav::KEYRING_PASSWORD) .ok() .flatten() .map(|value| !value.is_empty()) .unwrap_or(false); Ok(WebdavStatus { configured: settings.webdav.is_configured(), has_password, remote_root: settings.webdav.remote_root.clone(), }) } /// WebDAV 配置状态(不包含密码本身)。 #[derive(Debug, Clone, serde::Serialize, specta::Type)] #[serde(rename_all = "camelCase")] pub struct WebdavStatus { /// 地址与用户名是否已填 pub configured: bool, /// keyring 里是否已存密码 pub has_password: bool, pub remote_root: String, } /// 保存 WebDAV 密码到系统凭据管理器(传空串 = 删除)。 #[tauri::command] #[specta::specta] pub fn editor_set_webdav_password(password: String) -> Result<(), String> { if password.trim().is_empty() { return crate::secrets::secret_delete(webdav::KEYRING_PASSWORD); } crate::secrets::secret_write(webdav::KEYRING_PASSWORD, password.trim()) } /// 连接自检(建目录 + 列远端)。 #[tauri::command] #[specta::specta] pub async fn editor_test_webdav( state: State<'_, EditorManager>, ) -> Result { let settings = state.load_settings().webdav; run_blocking(move || webdav::test_connection(&settings)).await } /// 立即同步(并按设置决定是否追加一次快照备份)。 #[tauri::command] #[specta::specta] pub async fn editor_sync_now( app: AppHandle, state: State<'_, EditorManager>, ) -> Result { let settings = state.load_settings(); let webdav = settings.webdav.clone(); let root = library::resolve_library_root(state.module_dir(), &settings); library::ensure_library(&root)?; // 让前端先看到「开始同步」(进度事件的第一条由 worker 之外发,总数为 0 表示准备中) let _ = app.emit( events::EDITOR_SYNC_PROGRESS, SyncProgress { done: 0, total: 0, current: String::new(), kind: "prepare".to_string(), message: "正在比对清单…".to_string(), }, ); let app_for_task = app.clone(); let outcome = run_blocking(move || { let client = webdav::client_from(&webdav)?; client.ensure_root()?; let (report, backup) = backup::sync_then_backup(&root, &webdav, &client, &app_for_task, true)?; Ok(SyncOutcome { report, backup, }) }) .await; // 同步会改本地文件 → 索引必须跟着更新 mark_written_then_index(&app, &state); emit_library_changed(&app); outcome } /// 一次同步的结果(报告 + 可选快照)。 #[derive(Debug, Clone, serde::Serialize, specta::Type)] #[serde(rename_all = "camelCase")] pub struct SyncOutcome { pub report: super::webdav::sync::SyncReport, pub backup: Option, } /// 只做一次 zip 快照备份(不上传增量)。 #[tauri::command] #[specta::specta] pub async fn editor_backup_now( state: State<'_, EditorManager>, ) -> Result { let settings = state.load_settings(); let webdav = settings.webdav.clone(); let root = library::resolve_library_root(state.module_dir(), &settings); library::ensure_library(&root)?; run_blocking(move || { let client = webdav::client_from(&webdav)?; client.ensure_root()?; backup::upload_snapshot(&root, &webdav, &client) }) .await } /// 列出远端已有快照。 #[tauri::command] #[specta::specta] pub async fn editor_list_backups( state: State<'_, EditorManager>, ) -> Result, String> { let settings = state.load_settings().webdav; run_blocking(move || { let client = webdav::client_from(&settings)?; backup::list_snapshots(&client) }) .await } /// 从远端快照恢复(不覆盖本地已有文件)。 #[tauri::command] #[specta::specta] pub async fn editor_restore_backup( app: AppHandle, state: State<'_, EditorManager>, name: String, ) -> Result { let settings = state.load_settings(); let webdav = settings.webdav.clone(); let root = library::resolve_library_root(state.module_dir(), &settings); library::ensure_library(&root)?; let result = run_blocking(move || { let client = webdav::client_from(&webdav)?; let (written, kept) = backup::restore_snapshot(&root, &client, &name)?; Ok(ImportReport { imported: written, renamed: 0, skipped: kept, failures: Vec::new(), }) }) .await; mark_written_then_index(&app, &state); emit_library_changed(&app); result } /// 把阻塞的 WebDAV 调用挪到专用线程池,避免占住 Tauri 的命令线程。 /// /// `reqwest::blocking` 在 tokio 运行时线程上会 panic(它内部会尝试建一个运行时), /// 因此**必须**走 `spawn_blocking` 而不是直接 `.await` 一个同步函数。 async fn run_blocking(task: F) -> Result where T: Send + 'static, F: FnOnce() -> Result + Send + 'static, { match tokio::task::spawn_blocking(task).await { Ok(result) => result, Err(e) => Err(format!("后台任务执行失败: {e}")), } }