Files
Thing/src-tauri/src/editor/commands.rs
T
2026-10-10 14:29:48 +08:00

978 lines
34 KiB
Rust
Raw Blame History

This file contains ambiguous Unicode characters
This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.
//! 笔记模块 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<LibraryInfo, String> {
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<EditorSettings, String> {
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<String, String> {
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<EditorSettings, String> {
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<LibraryInfo, String> {
library_info(&state)
}
/// 设置库根(`None` 或空串 = 恢复默认库根)。
#[tauri::command]
#[specta::specta]
pub fn editor_set_library_root(
app: AppHandle,
state: State<'_, EditorManager>,
root: Option<String>,
) -> Result<LibraryInfo, String> {
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<Vec<LibraryEntry>, 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<NoteDoc, String> {
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<NoteDoc, String> {
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<String>,
) -> Result<NoteDoc, String> {
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<NoteDoc, String> {
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<String, String> {
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<NoteIndexReport, String> {
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<NoteIndexReport, String> {
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<NoteSearchPage, String> {
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<i64>,
) -> Result<Vec<NoteSearchHit>, 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<Vec<super::index::NoteTagCount>, 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<NoteBacklinks, String> {
let service = indexed(&app, &state)?;
service.backlinks(&rel_path)
}
/// 全库链接图(已解析的内部链接边)。
#[tauri::command]
#[specta::specta]
pub fn editor_link_graph(
app: AppHandle,
state: State<'_, EditorManager>,
) -> Result<Vec<LinkEdge>, 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<NoteIndexStats, String> {
let service = indexed(&app, &state)?;
service.stats()
}
// ===== 库外任意文件 =====
/// 把库内图片读成 `data:` URL(供编辑器内联预览)。
///
/// # 为什么走 data URL 而不是 asset 协议
///
/// 库根是用户自选目录,可以用 `convertFileSrc` + `assetProtocol.scope` 直接把磁盘路径
/// 交给 `<img>`。但那条路要求把「用户选的任意目录」加进 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<Option<String>, 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<Option<super::args::OpenTargetPayload>, String> {
Ok(super::args::take_pending_target())
}
/// 打开(读取)库外任意文件。
///
/// 读取本身不要求预先授权(用户可能刚通过系统对话框选完,也可能带命令行参数),
/// 但**读取会顺带登记授权** —— 于是「打开过就能保存」这条最符合直觉的规则成立。
#[tauri::command]
#[specta::specta]
pub fn editor_open_file(
state: State<'_, EditorManager>,
path: String,
) -> Result<files::FileDoc, String> {
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<files::FileDoc, String> {
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<files::FileDoc, String> {
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<String, String> {
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<Vec<NoteTemplate>, 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<String>,
body: Option<String>,
) -> Result<Vec<String>, 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<TemplateSource, String> {
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<String>,
}
// ===== 导入 / 导出(P2) =====
/// 从磁盘路径导入(文件 / 目录 / zip 自动判别)。
#[tauri::command]
#[specta::specta]
pub fn editor_import(
app: AppHandle,
state: State<'_, EditorManager>,
source: String,
dest_dir: String,
) -> Result<ImportReport, String> {
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<String, String> {
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<String>,
) -> Result<String, String> {
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<String>,
) -> Result<String, String> {
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<WebdavStatus, String> {
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<WebdavTestResult, String> {
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<SyncOutcome, String> {
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<BackupReport>,
}
/// 只做一次 zip 快照备份(不上传增量)。
#[tauri::command]
#[specta::specta]
pub async fn editor_backup_now(
state: State<'_, EditorManager>,
) -> Result<BackupReport, String> {
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<Vec<BackupSnapshot>, 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<ImportReport, String> {
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<T, F>(task: F) -> Result<T, String>
where
T: Send + 'static,
F: FnOnce() -> Result<T, String> + Send + 'static,
{
match tokio::task::spawn_blocking(task).await {
Ok(result) => result,
Err(e) => Err(format!("后台任务执行失败: {e}")),
}
}