diff --git a/Cargo.lock b/Cargo.lock
index d46aeaa..6a555d2 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -1672,6 +1672,12 @@ dependencies = [
  "pin-project-lite",
 ]
 
+[[package]]
+name = "http-range"
+version = "0.1.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "21dec9db110f5f872ed9699c3ecf50cf16f423502706ba5c72462e28d3157573"
+
 [[package]]
 name = "httparse"
 version = "1.10.1"
@@ -2304,6 +2310,7 @@ name = "mixvideo-desktop"
 version = "0.1.9"
 dependencies = [
  "anyhow",
+ "base64 0.22.1",
  "chrono",
  "dirs 5.0.1",
  "lazy_static",
@@ -4184,6 +4191,7 @@ dependencies = [
  "gtk",
  "heck 0.5.0",
  "http 1.3.1",
+ "http-range",
  "jni",
  "libc",
  "log",
diff --git a/apps/desktop/src-tauri/Cargo.toml b/apps/desktop/src-tauri/Cargo.toml
index 109e4f5..136cb4d 100644
--- a/apps/desktop/src-tauri/Cargo.toml
+++ b/apps/desktop/src-tauri/Cargo.toml
@@ -18,7 +18,7 @@ crate-type = ["staticlib", "cdylib", "rlib"]
 tauri-build = { version = "2", features = [] }
 
 [dependencies]
-tauri = { version = "2", features = [] }
+tauri = { version = "2", features = ["protocol-asset"] }
 tauri-plugin-opener = "2"
 tauri-plugin-fs = "2"
 tauri-plugin-dialog = "2"
@@ -33,6 +33,7 @@ thiserror = "1.0"
 dirs = "5.0"
 md5 = "0.7"
 lazy_static = "1.4"
+base64 = "0.22"
 tracing = "0.1"
 tracing-subscriber = { version = "0.3", features = ["env-filter", "chrono"] }
 tracing-appender = "0.2"
diff --git a/apps/desktop/src-tauri/src/lib.rs b/apps/desktop/src-tauri/src/lib.rs
index b330042..60981b4 100644
--- a/apps/desktop/src-tauri/src/lib.rs
+++ b/apps/desktop/src-tauri/src/lib.rs
@@ -11,10 +11,6 @@ pub mod presentation;
 pub mod app_state;
 pub mod config;
 
-// 测试模块
-#[cfg(test)]
-mod tests;
-
 use app_state::AppState;
 use presentation::commands;
 use tauri::Manager;
@@ -78,6 +74,7 @@ pub fn run() {
             commands::material_commands::detect_video_scenes,
             commands::material_commands::generate_video_thumbnail,
             commands::material_commands::generate_and_save_segment_thumbnail,
+            commands::material_commands::read_thumbnail_as_data_url,
             commands::material_commands::test_scene_detection,
             commands::material_commands::get_material_segments,
             commands::material_commands::test_video_split,
diff --git a/apps/desktop/src-tauri/src/presentation/commands/material_commands.rs b/apps/desktop/src-tauri/src/presentation/commands/material_commands.rs
index 0234883..881675f 100644
--- a/apps/desktop/src-tauri/src/presentation/commands/material_commands.rs
+++ b/apps/desktop/src-tauri/src/presentation/commands/material_commands.rs
@@ -851,6 +851,30 @@ pub async fn generate_and_save_segment_thumbnail(
     Ok(Some(thumbnail_path_str))
 }
 
+/// 读取缩略图文件并转换为base64数据URL
+#[command]
+pub async fn read_thumbnail_as_data_url(file_path: String) -> Result<String, String> {
+    use std::fs;
+    use base64::{Engine as _, engine::general_purpose};
+
+    // 去掉Windows长路径前缀
+    let clean_path = if file_path.starts_with("\\\\?\\") {
+        &file_path[4..]
+    } else {
+        &file_path
+    };
+
+    // 读取文件
+    let file_data = fs::read(clean_path)
+        .map_err(|e| format!("读取文件失败: {}", e))?;
+
+    // 转换为base64
+    let base64_data = general_purpose::STANDARD.encode(&file_data);
+
+    // 返回data URL
+    Ok(format!("data:image/jpeg;base64,{}", base64_data))
+}
+
 /// 测试场景检测命令（用于调试）
 #[command]
 pub async fn test_scene_detection(file_path: String) -> Result<String, String> {
diff --git a/apps/desktop/src-tauri/src/tests/integration/binding_management_integration_tests.rs b/apps/desktop/src-tauri/src/tests/integration/binding_management_integration_tests.rs
deleted file mode 100644
index ecfda42..0000000
--- a/apps/desktop/src-tauri/src/tests/integration/binding_management_integration_tests.rs
+++ /dev/null
@@ -1,437 +0,0 @@
-/**
- * 绑定管理功能集成测试
- * 测试项目-模板绑定和素材-模特绑定的完整工作流
- */
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-    use crate::data::models::{
-        project::Project,
-        template::Template,
-        material::{Material, MaterialType, ProcessingStatus},
-        model::Model,
-        project_template_binding::{ProjectTemplateBinding, BindingType, BindingStatus, CreateProjectTemplateBindingRequest},
-    };
-    use crate::data::repositories::{
-        project_repository::ProjectRepository,
-        template_repository::TemplateRepository,
-        material_repository::MaterialRepository,
-        model_repository::ModelRepository,
-        project_template_binding_repository::ProjectTemplateBindingRepository,
-    };
-    use crate::business::services::{
-        project_template_binding_service::ProjectTemplateBindingService,
-        material_service::MaterialService,
-    };
-    use crate::infrastructure::database::Database;
-    use std::sync::{Arc, Mutex};
-    use uuid::Uuid;
-
-    /// 创建完整的测试数据库
-    fn create_integration_test_database() -> Arc<Mutex<rusqlite::Connection>> {
-        let conn = rusqlite::Connection::open_in_memory().unwrap();
-        
-        // 创建所有必要的表
-        conn.execute(
-            "CREATE TABLE projects (
-                id TEXT PRIMARY KEY,
-                name TEXT NOT NULL,
-                path TEXT NOT NULL,
-                description TEXT,
-                created_at DATETIME DEFAULT CURRENT_TIMESTAMP,
-                updated_at DATETIME DEFAULT CURRENT_TIMESTAMP
-            )",
-            [],
-        ).unwrap();
-
-        conn.execute(
-            "CREATE TABLE templates (
-                id TEXT PRIMARY KEY,
-                name TEXT NOT NULL,
-                description TEXT,
-                file_path TEXT NOT NULL,
-                import_status TEXT NOT NULL,
-                project_id TEXT,
-                created_at DATETIME DEFAULT CURRENT_TIMESTAMP,
-                updated_at DATETIME DEFAULT CURRENT_TIMESTAMP
-            )",
-            [],
-        ).unwrap();
-
-        conn.execute(
-            "CREATE TABLE materials (
-                id TEXT PRIMARY KEY,
-                project_id TEXT NOT NULL,
-                name TEXT NOT NULL,
-                original_path TEXT NOT NULL,
-                file_size INTEGER NOT NULL,
-                md5_hash TEXT NOT NULL,
-                material_type TEXT NOT NULL,
-                processing_status TEXT NOT NULL,
-                metadata TEXT,
-                scene_detection TEXT,
-                model_id TEXT,
-                created_at DATETIME DEFAULT CURRENT_TIMESTAMP,
-                updated_at DATETIME DEFAULT CURRENT_TIMESTAMP,
-                processed_at DATETIME,
-                error_message TEXT
-            )",
-            [],
-        ).unwrap();
-
-        conn.execute(
-            "CREATE TABLE models (
-                id TEXT PRIMARY KEY,
-                name TEXT NOT NULL,
-                stage_name TEXT,
-                description TEXT,
-                avatar_url TEXT,
-                tags TEXT,
-                is_active INTEGER DEFAULT 1,
-                created_at DATETIME DEFAULT CURRENT_TIMESTAMP,
-                updated_at DATETIME DEFAULT CURRENT_TIMESTAMP
-            )",
-            [],
-        ).unwrap();
-
-        conn.execute(
-            "CREATE TABLE project_template_bindings (
-                id TEXT PRIMARY KEY,
-                project_id TEXT NOT NULL,
-                template_id TEXT NOT NULL,
-                binding_name TEXT,
-                description TEXT,
-                priority INTEGER DEFAULT 0,
-                is_active INTEGER DEFAULT 1,
-                binding_type TEXT NOT NULL,
-                binding_status TEXT NOT NULL,
-                metadata TEXT,
-                created_at DATETIME DEFAULT CURRENT_TIMESTAMP,
-                updated_at DATETIME DEFAULT CURRENT_TIMESTAMP,
-                UNIQUE (project_id, template_id)
-            )",
-            [],
-        ).unwrap();
-
-        Arc::new(Mutex::new(conn))
-    }
-
-    /// 创建测试数据
-    struct TestData {
-        project: Project,
-        templates: Vec<Template>,
-        materials: Vec<Material>,
-        models: Vec<Model>,
-    }
-
-    fn create_test_data(conn: &Arc<Mutex<rusqlite::Connection>>) -> TestData {
-        let project_repo = ProjectRepository::new(conn.clone());
-        let template_repo = TemplateRepository::new(conn.clone());
-        let material_repo = MaterialRepository::new(conn.clone());
-        let model_repo = ModelRepository::new(conn.clone());
-
-        // 创建项目
-        let project = Project {
-            id: Uuid::new_v4().to_string(),
-            name: "测试项目".to_string(),
-            path: "/path/to/project".to_string(),
-            description: Some("这是一个测试项目".to_string()),
-            created_at: chrono::Utc::now(),
-            updated_at: chrono::Utc::now(),
-        };
-        let project = project_repo.create(project).unwrap();
-
-        // 创建模板
-        let templates = vec![
-            Template {
-                id: Uuid::new_v4().to_string(),
-                name: "主要模板".to_string(),
-                description: Some("这是主要模板".to_string()),
-                file_path: "/path/to/template1".to_string(),
-                import_status: crate::data::models::template::ImportStatus::Completed,
-                project_id: None,
-                created_at: chrono::Utc::now(),
-                updated_at: chrono::Utc::now(),
-            },
-            Template {
-                id: Uuid::new_v4().to_string(),
-                name: "次要模板".to_string(),
-                description: Some("这是次要模板".to_string()),
-                file_path: "/path/to/template2".to_string(),
-                import_status: crate::data::models::template::ImportStatus::Completed,
-                project_id: None,
-                created_at: chrono::Utc::now(),
-                updated_at: chrono::Utc::now(),
-            },
-        ];
-        let templates: Vec<Template> = templates.into_iter()
-            .map(|t| template_repo.create(t).unwrap())
-            .collect();
-
-        // 创建模特
-        let models = vec![
-            Model {
-                id: Uuid::new_v4().to_string(),
-                name: "模特A".to_string(),
-                stage_name: Some("艺名A".to_string()),
-                description: Some("这是模特A".to_string()),
-                avatar_url: None,
-                tags: vec!["标签1".to_string(), "标签2".to_string()],
-                is_active: true,
-                created_at: chrono::Utc::now(),
-                updated_at: chrono::Utc::now(),
-            },
-            Model {
-                id: Uuid::new_v4().to_string(),
-                name: "模特B".to_string(),
-                stage_name: Some("艺名B".to_string()),
-                description: Some("这是模特B".to_string()),
-                avatar_url: None,
-                tags: vec!["标签3".to_string()],
-                is_active: true,
-                created_at: chrono::Utc::now(),
-                updated_at: chrono::Utc::now(),
-            },
-        ];
-        let models: Vec<Model> = models.into_iter()
-            .map(|m| model_repo.create(m).unwrap())
-            .collect();
-
-        // 创建素材
-        let materials = vec![
-            Material {
-                id: Uuid::new_v4().to_string(),
-                project_id: project.id.clone(),
-                name: "视频素材1.mp4".to_string(),
-                original_path: "/path/to/video1.mp4".to_string(),
-                file_size: 1024000,
-                md5_hash: "hash1".to_string(),
-                material_type: MaterialType::Video,
-                processing_status: ProcessingStatus::Completed,
-                metadata: None,
-                scene_detection: None,
-                model_id: None,
-                created_at: chrono::Utc::now(),
-                updated_at: chrono::Utc::now(),
-                processed_at: Some(chrono::Utc::now()),
-                error_message: None,
-            },
-            Material {
-                id: Uuid::new_v4().to_string(),
-                project_id: project.id.clone(),
-                name: "视频素材2.mp4".to_string(),
-                original_path: "/path/to/video2.mp4".to_string(),
-                file_size: 2048000,
-                md5_hash: "hash2".to_string(),
-                material_type: MaterialType::Video,
-                processing_status: ProcessingStatus::Completed,
-                metadata: None,
-                scene_detection: None,
-                model_id: None,
-                created_at: chrono::Utc::now(),
-                updated_at: chrono::Utc::now(),
-                processed_at: Some(chrono::Utc::now()),
-                error_message: None,
-            },
-        ];
-        let materials: Vec<Material> = materials.into_iter()
-            .map(|m| material_repo.create(m).unwrap())
-            .collect();
-
-        TestData {
-            project,
-            templates,
-            materials,
-            models,
-        }
-    }
-
-    #[tokio::test]
-    async fn test_complete_project_template_binding_workflow() {
-        let conn = create_integration_test_database();
-        let test_data = create_test_data(&conn);
-        let binding_service = ProjectTemplateBindingService::new(conn.clone()).unwrap();
-
-        // 1. 创建主要模板绑定
-        let primary_binding_request = CreateProjectTemplateBindingRequest {
-            project_id: test_data.project.id.clone(),
-            template_id: test_data.templates[0].id.clone(),
-            binding_name: Some("主要绑定".to_string()),
-            description: Some("这是主要模板绑定".to_string()),
-            priority: Some(0),
-            binding_type: BindingType::Primary,
-        };
-
-        let primary_binding = binding_service.create_binding(primary_binding_request).await.unwrap();
-        assert_eq!(primary_binding.binding_type, BindingType::Primary);
-        assert_eq!(primary_binding.priority, 0);
-
-        // 2. 创建次要模板绑定
-        let secondary_binding_request = CreateProjectTemplateBindingRequest {
-            project_id: test_data.project.id.clone(),
-            template_id: test_data.templates[1].id.clone(),
-            binding_name: Some("次要绑定".to_string()),
-            description: Some("这是次要模板绑定".to_string()),
-            priority: Some(1),
-            binding_type: BindingType::Secondary,
-        };
-
-        let secondary_binding = binding_service.create_binding(secondary_binding_request).await.unwrap();
-        assert_eq!(secondary_binding.binding_type, BindingType::Secondary);
-        assert_eq!(secondary_binding.priority, 1);
-
-        // 3. 获取项目的所有绑定
-        let bindings = binding_service.get_bindings_by_project(&test_data.project.id).await.unwrap();
-        assert_eq!(bindings.len(), 2);
-
-        // 验证排序（按优先级）
-        assert_eq!(bindings[0].priority, 0);
-        assert_eq!(bindings[1].priority, 1);
-
-        // 4. 更新绑定状态
-        let updated_binding = binding_service.toggle_binding_status(&secondary_binding.id).await.unwrap();
-        assert_eq!(updated_binding.binding_status, BindingStatus::Paused);
-
-        // 5. 删除绑定
-        let deleted = binding_service.delete_binding(&secondary_binding.id).await.unwrap();
-        assert!(deleted);
-
-        // 验证删除
-        let remaining_bindings = binding_service.get_bindings_by_project(&test_data.project.id).await.unwrap();
-        assert_eq!(remaining_bindings.len(), 1);
-        assert_eq!(remaining_bindings[0].id, primary_binding.id);
-    }
-
-    #[tokio::test]
-    async fn test_complete_material_model_binding_workflow() {
-        let conn = create_integration_test_database();
-        let test_data = create_test_data(&conn);
-        let material_service = MaterialService::new(conn.clone()).unwrap();
-
-        // 1. 绑定第一个素材到第一个模特
-        let result = material_service.bind_material_to_model(
-            &test_data.materials[0].id,
-            &test_data.models[0].id
-        ).await;
-        assert!(result.is_ok());
-
-        // 验证绑定
-        let material = material_service.get_material_by_id(&test_data.materials[0].id).await.unwrap().unwrap();
-        assert_eq!(material.model_id, Some(test_data.models[0].id.clone()));
-
-        // 2. 绑定第二个素材到第二个模特
-        let result = material_service.bind_material_to_model(
-            &test_data.materials[1].id,
-            &test_data.models[1].id
-        ).await;
-        assert!(result.is_ok());
-
-        // 3. 获取第一个模特的所有素材
-        let model_materials = material_service.get_materials_by_model(&test_data.models[0].id).await.unwrap();
-        assert_eq!(model_materials.len(), 1);
-        assert_eq!(model_materials[0].id, test_data.materials[0].id);
-
-        // 4. 切换第一个素材到第二个模特
-        let result = material_service.bind_material_to_model(
-            &test_data.materials[0].id,
-            &test_data.models[1].id
-        ).await;
-        assert!(result.is_ok());
-
-        // 验证切换
-        let updated_material = material_service.get_material_by_id(&test_data.materials[0].id).await.unwrap().unwrap();
-        assert_eq!(updated_material.model_id, Some(test_data.models[1].id.clone()));
-
-        // 验证第二个模特现在有两个素材
-        let model2_materials = material_service.get_materials_by_model(&test_data.models[1].id).await.unwrap();
-        assert_eq!(model2_materials.len(), 2);
-
-        // 验证第一个模特现在没有素材
-        let model1_materials = material_service.get_materials_by_model(&test_data.models[0].id).await.unwrap();
-        assert_eq!(model1_materials.len(), 0);
-
-        // 5. 解除绑定
-        let result = material_service.unbind_material_from_model(&test_data.materials[0].id).await;
-        assert!(result.is_ok());
-
-        // 验证解除绑定
-        let unbound_material = material_service.get_material_by_id(&test_data.materials[0].id).await.unwrap().unwrap();
-        assert_eq!(unbound_material.model_id, None);
-    }
-
-    #[tokio::test]
-    async fn test_cross_feature_integration() {
-        let conn = create_integration_test_database();
-        let test_data = create_test_data(&conn);
-        let binding_service = ProjectTemplateBindingService::new(conn.clone()).unwrap();
-        let material_service = MaterialService::new(conn.clone()).unwrap();
-
-        // 1. 创建项目-模板绑定
-        let binding_request = CreateProjectTemplateBindingRequest {
-            project_id: test_data.project.id.clone(),
-            template_id: test_data.templates[0].id.clone(),
-            binding_name: Some("集成测试绑定".to_string()),
-            description: None,
-            priority: Some(0),
-            binding_type: BindingType::Primary,
-        };
-
-        let binding = binding_service.create_binding(binding_request).await.unwrap();
-
-        // 2. 绑定素材到模特
-        material_service.bind_material_to_model(
-            &test_data.materials[0].id,
-            &test_data.models[0].id
-        ).await.unwrap();
-
-        // 3. 验证项目现在有绑定的模板和素材
-        let project_bindings = binding_service.get_bindings_by_project(&test_data.project.id).await.unwrap();
-        assert_eq!(project_bindings.len(), 1);
-
-        let project_materials = material_service.get_materials_by_project(&test_data.project.id).await.unwrap();
-        let bound_materials: Vec<_> = project_materials.iter()
-            .filter(|m| m.model_id.is_some())
-            .collect();
-        assert_eq!(bound_materials.len(), 1);
-
-        // 4. 模拟完整的工作流：项目有模板绑定，素材有模特绑定
-        // 这种情况下，项目可以使用绑定的模板进行视频制作，
-        // 同时素材已经标识了相关的模特
-        assert_eq!(binding.project_id, test_data.project.id);
-        assert_eq!(bound_materials[0].project_id, test_data.project.id);
-        assert_eq!(bound_materials[0].model_id, Some(test_data.models[0].id.clone()));
-    }
-
-    #[test]
-    fn test_binding_constraints_and_validation() {
-        let conn = create_integration_test_database();
-        let test_data = create_test_data(&conn);
-        let binding_repo = ProjectTemplateBindingRepository::new(conn.clone());
-
-        // 1. 测试唯一约束：不能重复绑定相同的项目-模板组合
-        let request1 = CreateProjectTemplateBindingRequest {
-            project_id: test_data.project.id.clone(),
-            template_id: test_data.templates[0].id.clone(),
-            binding_name: Some("第一个绑定".to_string()),
-            description: None,
-            priority: Some(0),
-            binding_type: BindingType::Primary,
-        };
-
-        let binding1 = binding_repo.create(request1.clone()).unwrap();
-        assert!(binding1.id.len() > 0);
-
-        // 尝试创建重复绑定应该失败
-        let result2 = binding_repo.create(request1);
-        assert!(result2.is_err());
-
-        // 2. 测试数据完整性
-        let retrieved_binding = binding_repo.get_by_id(&binding1.id).unwrap().unwrap();
-        assert_eq!(retrieved_binding.project_id, test_data.project.id);
-        assert_eq!(retrieved_binding.template_id, test_data.templates[0].id);
-        assert_eq!(retrieved_binding.binding_type, BindingType::Primary);
-        assert_eq!(retrieved_binding.binding_status, BindingStatus::Active);
-        assert!(retrieved_binding.is_active);
-    }
-}
diff --git a/apps/desktop/src-tauri/src/tests/material_model_binding_tests.rs b/apps/desktop/src-tauri/src/tests/material_model_binding_tests.rs
deleted file mode 100644
index abf0b77..0000000
--- a/apps/desktop/src-tauri/src/tests/material_model_binding_tests.rs
+++ /dev/null
@@ -1,360 +0,0 @@
-/**
- * 素材-模特绑定功能测试
- * 遵循 Tauri 开发规范的测试设计原则
- */
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-    use crate::data::models::material::Material;
-    use crate::data::models::model::Model;
-    use crate::data::repositories::material_repository::MaterialRepository;
-    use crate::data::repositories::model_repository::ModelRepository;
-    use crate::business::services::material_service::MaterialService;
-    use crate::infrastructure::database::Database;
-    use std::sync::{Arc, Mutex};
-    use uuid::Uuid;
-
-    /// 创建测试数据库连接
-    fn create_test_database() -> Arc<Mutex<rusqlite::Connection>> {
-        let conn = rusqlite::Connection::open_in_memory().unwrap();
-        
-        // 创建素材表
-        conn.execute(
-            "CREATE TABLE materials (
-                id TEXT PRIMARY KEY,
-                project_id TEXT NOT NULL,
-                name TEXT NOT NULL,
-                original_path TEXT NOT NULL,
-                file_size INTEGER NOT NULL,
-                md5_hash TEXT NOT NULL,
-                material_type TEXT NOT NULL,
-                processing_status TEXT NOT NULL,
-                metadata TEXT,
-                scene_detection TEXT,
-                model_id TEXT,
-                created_at DATETIME DEFAULT CURRENT_TIMESTAMP,
-                updated_at DATETIME DEFAULT CURRENT_TIMESTAMP,
-                processed_at DATETIME,
-                error_message TEXT
-            )",
-            [],
-        ).unwrap();
-
-        // 创建模特表
-        conn.execute(
-            "CREATE TABLE models (
-                id TEXT PRIMARY KEY,
-                name TEXT NOT NULL,
-                stage_name TEXT,
-                description TEXT,
-                avatar_url TEXT,
-                tags TEXT,
-                is_active INTEGER DEFAULT 1,
-                created_at DATETIME DEFAULT CURRENT_TIMESTAMP,
-                updated_at DATETIME DEFAULT CURRENT_TIMESTAMP
-            )",
-            [],
-        ).unwrap();
-
-        Arc::new(Mutex::new(conn))
-    }
-
-    /// 创建测试模特
-    fn create_test_model(conn: &Arc<Mutex<rusqlite::Connection>>) -> Model {
-        let model_repository = ModelRepository::new(conn.clone());
-        let model = Model {
-            id: Uuid::new_v4().to_string(),
-            name: "测试模特".to_string(),
-            stage_name: Some("艺名".to_string()),
-            description: Some("这是一个测试模特".to_string()),
-            avatar_url: None,
-            tags: vec!["标签1".to_string(), "标签2".to_string()],
-            is_active: true,
-            created_at: chrono::Utc::now(),
-            updated_at: chrono::Utc::now(),
-        };
-
-        model_repository.create(model).unwrap()
-    }
-
-    /// 创建测试素材
-    fn create_test_material(
-        conn: &Arc<Mutex<rusqlite::Connection>>,
-        model_id: Option<String>,
-    ) -> Material {
-        let material_repository = MaterialRepository::new(conn.clone());
-        let material = Material {
-            id: Uuid::new_v4().to_string(),
-            project_id: Uuid::new_v4().to_string(),
-            name: "测试素材.mp4".to_string(),
-            original_path: "/path/to/test.mp4".to_string(),
-            file_size: 1024000,
-            md5_hash: "abcd1234".to_string(),
-            material_type: crate::data::models::material::MaterialType::Video,
-            processing_status: crate::data::models::material::ProcessingStatus::Completed,
-            metadata: None,
-            scene_detection: None,
-            model_id,
-            created_at: chrono::Utc::now(),
-            updated_at: chrono::Utc::now(),
-            processed_at: Some(chrono::Utc::now()),
-            error_message: None,
-        };
-
-        material_repository.create(material).unwrap()
-    }
-
-    #[test]
-    fn test_bind_material_to_model() {
-        let conn = create_test_database();
-        let material_repository = MaterialRepository::new(conn.clone());
-        
-        // 创建模特和素材
-        let model = create_test_model(&conn);
-        let material = create_test_material(&conn, None);
-
-        // 绑定素材到模特
-        let result = material_repository.update_model_binding(&material.id, Some(&model.id));
-        assert!(result.is_ok());
-
-        // 验证绑定
-        let updated_material = material_repository.get_by_id(&material.id).unwrap().unwrap();
-        assert_eq!(updated_material.model_id, Some(model.id));
-    }
-
-    #[test]
-    fn test_unbind_material_from_model() {
-        let conn = create_test_database();
-        let material_repository = MaterialRepository::new(conn.clone());
-        
-        // 创建模特和已绑定的素材
-        let model = create_test_model(&conn);
-        let material = create_test_material(&conn, Some(model.id.clone()));
-
-        // 验证初始绑定
-        assert_eq!(material.model_id, Some(model.id));
-
-        // 解除绑定
-        let result = material_repository.update_model_binding(&material.id, None);
-        assert!(result.is_ok());
-
-        // 验证解除绑定
-        let updated_material = material_repository.get_by_id(&material.id).unwrap().unwrap();
-        assert_eq!(updated_material.model_id, None);
-    }
-
-    #[test]
-    fn test_get_materials_by_model() {
-        let conn = create_test_database();
-        let material_repository = MaterialRepository::new(conn.clone());
-        
-        // 创建模特
-        let model = create_test_model(&conn);
-        
-        // 创建多个素材，其中一些绑定到模特
-        let material1 = create_test_material(&conn, Some(model.id.clone()));
-        let material2 = create_test_material(&conn, Some(model.id.clone()));
-        let _material3 = create_test_material(&conn, None); // 未绑定
-
-        // 获取绑定到模特的素材
-        let result = material_repository.get_by_model_id(&model.id);
-        assert!(result.is_ok());
-        
-        let materials = result.unwrap();
-        assert_eq!(materials.len(), 2);
-        
-        let material_ids: Vec<String> = materials.iter().map(|m| m.id.clone()).collect();
-        assert!(material_ids.contains(&material1.id));
-        assert!(material_ids.contains(&material2.id));
-    }
-
-    #[test]
-    fn test_batch_bind_materials_to_model() {
-        let conn = create_test_database();
-        let material_repository = MaterialRepository::new(conn.clone());
-        
-        // 创建模特和多个素材
-        let model = create_test_model(&conn);
-        let material1 = create_test_material(&conn, None);
-        let material2 = create_test_material(&conn, None);
-        let material3 = create_test_material(&conn, None);
-        
-        let material_ids = vec![material1.id.clone(), material2.id.clone(), material3.id.clone()];
-
-        // 批量绑定
-        let result = material_repository.batch_update_model_binding(&material_ids, Some(&model.id));
-        assert!(result.is_ok());
-
-        // 验证所有素材都已绑定
-        for material_id in &material_ids {
-            let material = material_repository.get_by_id(material_id).unwrap().unwrap();
-            assert_eq!(material.model_id, Some(model.id.clone()));
-        }
-    }
-
-    #[test]
-    fn test_batch_unbind_materials_from_model() {
-        let conn = create_test_database();
-        let material_repository = MaterialRepository::new(conn.clone());
-        
-        // 创建模特和已绑定的素材
-        let model = create_test_model(&conn);
-        let material1 = create_test_material(&conn, Some(model.id.clone()));
-        let material2 = create_test_material(&conn, Some(model.id.clone()));
-        let material3 = create_test_material(&conn, Some(model.id.clone()));
-        
-        let material_ids = vec![material1.id.clone(), material2.id.clone(), material3.id.clone()];
-
-        // 批量解除绑定
-        let result = material_repository.batch_update_model_binding(&material_ids, None);
-        assert!(result.is_ok());
-
-        // 验证所有素材都已解除绑定
-        for material_id in &material_ids {
-            let material = material_repository.get_by_id(material_id).unwrap().unwrap();
-            assert_eq!(material.model_id, None);
-        }
-    }
-
-    #[test]
-    fn test_get_model_statistics() {
-        let conn = create_test_database();
-        let material_repository = MaterialRepository::new(conn.clone());
-        
-        // 创建模特
-        let model = create_test_model(&conn);
-        
-        // 创建不同类型的素材
-        let _video_material = create_test_material(&conn, Some(model.id.clone()));
-        let _audio_material = {
-            let mut material = create_test_material(&conn, Some(model.id.clone()));
-            material.material_type = crate::data::models::material::MaterialType::Audio;
-            material_repository.update(&material.id, material).unwrap()
-        };
-        let _image_material = {
-            let mut material = create_test_material(&conn, Some(model.id.clone()));
-            material.material_type = crate::data::models::material::MaterialType::Image;
-            material_repository.update(&material.id, material).unwrap()
-        };
-
-        // 获取模特统计信息
-        let result = material_repository.get_model_statistics(&model.id);
-        assert!(result.is_ok());
-        
-        let stats = result.unwrap();
-        assert_eq!(stats.total_materials, 3);
-        assert_eq!(stats.video_count, 1);
-        assert_eq!(stats.audio_count, 1);
-        assert_eq!(stats.image_count, 1);
-    }
-
-    #[tokio::test]
-    async fn test_business_service_bind_material() {
-        let conn = create_test_database();
-        let service = MaterialService::new(conn.clone()).unwrap();
-        
-        // 创建模特和素材
-        let model = create_test_model(&conn);
-        let material = create_test_material(&conn, None);
-
-        // 通过业务服务绑定
-        let result = service.bind_material_to_model(&material.id, &model.id).await;
-        assert!(result.is_ok());
-
-        // 验证绑定
-        let updated_material = service.get_material_by_id(&material.id).await.unwrap().unwrap();
-        assert_eq!(updated_material.model_id, Some(model.id));
-    }
-
-    #[tokio::test]
-    async fn test_business_service_validate_model_exists() {
-        let conn = create_test_database();
-        let service = MaterialService::new(conn.clone()).unwrap();
-        
-        // 创建素材
-        let material = create_test_material(&conn, None);
-        let non_existent_model_id = Uuid::new_v4().to_string();
-
-        // 尝试绑定到不存在的模特应该失败
-        let result = service.bind_material_to_model(&material.id, &non_existent_model_id).await;
-        assert!(result.is_err());
-    }
-
-    #[test]
-    fn test_material_model_binding_constraints() {
-        let conn = create_test_database();
-        let material_repository = MaterialRepository::new(conn.clone());
-        
-        // 创建素材
-        let material = create_test_material(&conn, None);
-        let non_existent_model_id = Uuid::new_v4().to_string();
-
-        // 尝试绑定到不存在的模特ID（在实际应用中应该有外键约束）
-        let result = material_repository.update_model_binding(&material.id, Some(&non_existent_model_id));
-        // 注意：在内存数据库中没有外键约束，所以这个测试可能会成功
-        // 在实际应用中，应该有适当的约束和验证
-        println!("绑定结果: {:?}", result);
-    }
-
-    #[test]
-    fn test_material_search_by_model() {
-        let conn = create_test_database();
-        let material_repository = MaterialRepository::new(conn.clone());
-        
-        // 创建多个模特
-        let model1 = create_test_model(&conn);
-        let model2 = create_test_model(&conn);
-        
-        // 创建素材并绑定到不同模特
-        let _material1 = create_test_material(&conn, Some(model1.id.clone()));
-        let _material2 = create_test_material(&conn, Some(model1.id.clone()));
-        let _material3 = create_test_material(&conn, Some(model2.id.clone()));
-        let _material4 = create_test_material(&conn, None); // 未绑定
-
-        // 搜索绑定到model1的素材
-        let materials1 = material_repository.get_by_model_id(&model1.id).unwrap();
-        assert_eq!(materials1.len(), 2);
-
-        // 搜索绑定到model2的素材
-        let materials2 = material_repository.get_by_model_id(&model2.id).unwrap();
-        assert_eq!(materials2.len(), 1);
-
-        // 搜索未绑定的素材
-        let unbound_materials = material_repository.get_unbound_materials().unwrap();
-        assert_eq!(unbound_materials.len(), 1);
-    }
-
-    #[test]
-    fn test_material_binding_history() {
-        let conn = create_test_database();
-        let material_repository = MaterialRepository::new(conn.clone());
-        
-        // 创建模特和素材
-        let model1 = create_test_model(&conn);
-        let model2 = create_test_model(&conn);
-        let material = create_test_material(&conn, None);
-
-        // 记录初始状态
-        let initial_material = material_repository.get_by_id(&material.id).unwrap().unwrap();
-        assert_eq!(initial_material.model_id, None);
-
-        // 绑定到第一个模特
-        material_repository.update_model_binding(&material.id, Some(&model1.id)).unwrap();
-        let bound_material1 = material_repository.get_by_id(&material.id).unwrap().unwrap();
-        assert_eq!(bound_material1.model_id, Some(model1.id.clone()));
-        assert!(bound_material1.updated_at > initial_material.updated_at);
-
-        // 切换到第二个模特
-        material_repository.update_model_binding(&material.id, Some(&model2.id)).unwrap();
-        let bound_material2 = material_repository.get_by_id(&material.id).unwrap().unwrap();
-        assert_eq!(bound_material2.model_id, Some(model2.id));
-        assert!(bound_material2.updated_at > bound_material1.updated_at);
-
-        // 解除绑定
-        material_repository.update_model_binding(&material.id, None).unwrap();
-        let unbound_material = material_repository.get_by_id(&material.id).unwrap().unwrap();
-        assert_eq!(unbound_material.model_id, None);
-        assert!(unbound_material.updated_at > bound_material2.updated_at);
-    }
-}
diff --git a/apps/desktop/src-tauri/src/tests/material_tests.rs b/apps/desktop/src-tauri/src/tests/material_tests.rs
deleted file mode 100644
index abf9637..0000000
--- a/apps/desktop/src-tauri/src/tests/material_tests.rs
+++ /dev/null
@@ -1,301 +0,0 @@
-#[cfg(test)]
-mod tests {
-    use crate::business::services::material_service::MaterialService;
-    use crate::data::models::material::{MaterialType, ProcessingStatus};
-    use crate::data::models::project::Project;
-    use crate::data::repositories::material_repository::MaterialRepository;
-    use crate::data::repositories::project_repository::ProjectRepository;
-    use crate::data::repositories::model_repository::ModelRepository;
-    use crate::infrastructure::database::Database;
-    use std::sync::{Arc, Mutex};
-    use tempfile::tempdir;
-    use std::fs::File;
-    use std::io::Write;
-
-    /// 创建测试数据库
-    fn create_test_database() -> anyhow::Result<Arc<Mutex<rusqlite::Connection>>> {
-        let temp_dir = tempdir()?;
-        let db_path = temp_dir.path().join("test.db");
-        let database = Database::new_with_path(db_path.to_str().unwrap())?;
-        Ok(database.get_connection())
-    }
-
-    /// 创建测试文件
-    fn create_test_file(content: &[u8]) -> anyhow::Result<(String, tempfile::TempDir)> {
-        let temp_dir = tempdir()?;
-        let file_path = temp_dir.path().join("test_file.txt");
-        let mut file = File::create(&file_path)?;
-        file.write_all(content)?;
-        file.flush()?;
-        Ok((file_path.to_string_lossy().to_string(), temp_dir))
-    }
-
-    #[test]
-    fn test_material_type_from_extension() {
-        assert_eq!(MaterialType::from_extension("mp4"), MaterialType::Video);
-        assert_eq!(MaterialType::from_extension("MP4"), MaterialType::Video);
-        assert_eq!(MaterialType::from_extension("mp3"), MaterialType::Audio);
-        assert_eq!(MaterialType::from_extension("jpg"), MaterialType::Image);
-        assert_eq!(MaterialType::from_extension("pdf"), MaterialType::Document);
-        assert_eq!(MaterialType::from_extension("unknown"), MaterialType::Other);
-    }
-
-    #[test]
-    fn test_supported_format_detection() {
-        assert!(MaterialService::is_supported_format("test.mp4"));
-        assert!(MaterialService::is_supported_format("test.MP3"));
-        assert!(MaterialService::is_supported_format("test.jpg"));
-        assert!(!MaterialService::is_supported_format("test.xyz"));
-        assert!(!MaterialService::is_supported_format("test"));
-    }
-
-    #[test]
-    fn test_supported_extensions() {
-        let extensions = MaterialService::get_supported_extensions();
-        assert!(extensions.contains(&"mp4"));
-        assert!(extensions.contains(&"mp3"));
-        assert!(extensions.contains(&"jpg"));
-        assert!(extensions.contains(&"pdf"));
-        assert!(extensions.len() > 20); // 应该有很多支持的格式
-    }
-
-    #[tokio::test]
-    async fn test_material_repository_crud() -> anyhow::Result<()> {
-        let connection = create_test_database()?;
-        let material_repository = MaterialRepository::new(connection.clone())?;
-        let project_repository = crate::data::repositories::project_repository::ProjectRepository::new(connection)?;
-
-        // 先创建一个测试项目
-        let test_project = crate::data::models::project::Project::new(
-            "Test Project".to_string(),
-            "/path/to/test/project".to_string(),
-            Some("Test project description".to_string()),
-        );
-        project_repository.create(&test_project)?;
-
-        // 创建测试素材
-        let mut material = crate::data::models::material::Material::new(
-            test_project.id.clone(),
-            "test_file.mp4".to_string(),
-            "/path/to/test_file.mp4".to_string(),
-            1024 * 1024, // 1MB
-            "test_md5_hash".to_string(),
-            MaterialType::Video,
-        );
-
-        // 测试创建
-        material_repository.create(&material)?;
-
-        // 测试读取
-        let retrieved = material_repository.get_by_id(&material.id)?;
-        assert!(retrieved.is_some());
-        let retrieved = retrieved.unwrap();
-        assert_eq!(retrieved.name, material.name);
-        assert_eq!(retrieved.project_id, material.project_id);
-
-        // 测试更新
-        material.update_status(ProcessingStatus::Completed, None);
-        material_repository.update(&material)?;
-
-        let updated = material_repository.get_by_id(&material.id)?.unwrap();
-        assert_eq!(updated.processing_status, ProcessingStatus::Completed);
-
-        // 测试MD5检查
-        assert!(material_repository.exists_by_md5(&test_project.id, "test_md5_hash")?);
-        assert!(!material_repository.exists_by_md5(&test_project.id, "different_hash")?);
-
-        // 测试按项目ID获取
-        let project_materials = material_repository.get_by_project_id(&test_project.id)?;
-        assert_eq!(project_materials.len(), 1);
-
-        // 测试删除
-        material_repository.delete(&material.id)?;
-        let deleted = material_repository.get_by_id(&material.id)?;
-        assert!(deleted.is_none());
-
-        Ok(())
-    }
-
-    #[test]
-    fn test_md5_calculation() -> anyhow::Result<()> {
-        let test_content = b"Hello, World!";
-        let (file_path, _temp_dir) = create_test_file(test_content)?;
-
-        // 计算MD5
-        let md5_hash = MaterialService::calculate_md5(&file_path)?;
-
-        // 验证MD5值（"Hello, World!" 的MD5是 65a8e27d8879283831b664bd8b7f0ad4）
-        assert_eq!(md5_hash, "65a8e27d8879283831b664bd8b7f0ad4");
-
-        Ok(())
-    }
-
-    #[test]
-    fn test_material_needs_segmentation() {
-        let mut material = crate::data::models::material::Material::new(
-            "test_project".to_string(),
-            "test.mp4".to_string(),
-            "/path/test.mp4".to_string(),
-            1000,
-            "hash".to_string(),
-            MaterialType::Video,
-        );
-
-        // 设置视频元数据
-        let video_metadata = crate::data::models::material::VideoMetadata {
-            duration: 600.0, // 10分钟
-            width: 1920,
-            height: 1080,
-            fps: 30.0,
-            bitrate: 5000000,
-            codec: "h264".to_string(),
-            format: "mp4".to_string(),
-            has_audio: true,
-            audio_codec: Some("aac".to_string()),
-            audio_bitrate: Some(128000),
-            audio_sample_rate: Some(44100),
-        };
-
-        material.set_metadata(crate::data::models::material::MaterialMetadata::Video(video_metadata));
-
-        // 测试是否需要切分
-        assert!(material.needs_segmentation(300.0)); // 5分钟限制，应该需要切分
-        assert!(!material.needs_segmentation(700.0)); // 11分钟限制，不需要切分
-    }
-
-    #[test]
-    fn test_create_fixed_segments() {
-        let segments = MaterialService::create_fixed_segments(900.0, 300.0); // 15分钟视频，5分钟片段
-        
-        assert_eq!(segments.len(), 3);
-        assert_eq!(segments[0], (0.0, 300.0));
-        assert_eq!(segments[1], (300.0, 600.0));
-        assert_eq!(segments[2], (600.0, 900.0));
-    }
-
-    #[test]
-    fn test_create_segments_from_scenes() {
-        let scenes = vec![
-            crate::data::models::material::SceneSegment {
-                start_time: 0.0,
-                end_time: 120.0,
-                duration: 120.0,
-                scene_id: 0,
-                confidence: 1.0,
-            },
-            crate::data::models::material::SceneSegment {
-                start_time: 120.0,
-                end_time: 240.0,
-                duration: 120.0,
-                scene_id: 1,
-                confidence: 1.0,
-            },
-            crate::data::models::material::SceneSegment {
-                start_time: 240.0,
-                end_time: 360.0,
-                duration: 120.0,
-                scene_id: 2,
-                confidence: 1.0,
-            },
-        ];
-
-        let segments = MaterialService::create_segments_from_scenes(&scenes, 300.0); // 5分钟限制
-        
-        // 前两个场景应该合并为一个片段（240秒 < 300秒）
-        // 第三个场景单独成为一个片段
-        assert_eq!(segments.len(), 2);
-        assert_eq!(segments[0], (0.0, 240.0));
-        assert_eq!(segments[1], (240.0, 360.0));
-    }
-
-    #[tokio::test]
-    async fn test_material_import_with_auto_process() -> anyhow::Result<()> {
-        let connection = create_test_database()?;
-        let material_repository = MaterialRepository::new(connection.clone())?;
-        let project_repository = crate::data::repositories::project_repository::ProjectRepository::new(connection)?;
-
-        // 创建测试项目
-        let test_project = crate::data::models::project::Project::new(
-            "Test Project".to_string(),
-            "/path/to/test/project".to_string(),
-            Some("Test project description".to_string()),
-        );
-        project_repository.create(&test_project)?;
-
-        // 创建测试文件
-        let (test_file_path, _temp_dir) = create_test_file(b"test content for material")?;
-
-        // 创建导入请求
-        let request = crate::data::models::material::CreateMaterialRequest {
-            project_id: test_project.id.clone(),
-            file_paths: vec![test_file_path],
-            auto_process: true,
-            max_segment_duration: Some(300.0),
-            model_id: None,
-        };
-
-        // 创建处理配置
-        let config = crate::data::models::material::MaterialProcessingConfig {
-            auto_process: Some(true),
-            ..Default::default()
-        };
-
-        // 执行导入
-        let result = MaterialService::import_materials(&material_repository, request, &config)?;
-
-        // 验证结果
-        assert_eq!(result.total_files, 1);
-        assert_eq!(result.processed_files, 1);
-        assert_eq!(result.failed_files, 0);
-        assert_eq!(result.created_materials.len(), 1);
-
-        // 验证素材状态
-        let imported_material = &result.created_materials[0];
-
-        // 由于我们启用了自动处理，状态应该是 Completed 而不是 Pending
-        // 注意：在没有FFmpeg的环境中，元数据提取可能失败，但状态仍应更新
-        assert_ne!(imported_material.processing_status, ProcessingStatus::Pending);
-
-        // 验证素材已保存到数据库
-        let saved_material = material_repository.get_by_id(&imported_material.id)?;
-        assert!(saved_material.is_some());
-
-        Ok(())
-    }
-
-    #[test]
-    fn test_material_stats_calculation() {
-        // 这个测试需要实际的数据库连接，所以暂时跳过
-        // 在实际项目中，可以使用模拟数据库或测试数据库
-    }
-
-    #[test]
-    fn test_import_materials_with_model_binding() {
-        // 测试素材导入时的模特绑定功能
-        // 由于测试环境复杂性，这里只验证数据结构的正确性
-
-        // 验证 CreateMaterialRequest 包含 model_id 字段
-        let request = crate::data::models::material::CreateMaterialRequest {
-            project_id: "test_project".to_string(),
-            file_paths: vec!["test.mp4".to_string()],
-            auto_process: true,
-            max_segment_duration: Some(300.0),
-            model_id: Some("test_model_id".to_string()),
-        };
-
-        assert_eq!(request.model_id, Some("test_model_id".to_string()));
-
-        // 验证 Material::new_with_model 方法
-        let material = crate::data::models::material::Material::new_with_model(
-            "project_id".to_string(),
-            "test.mp4".to_string(),
-            "/path/to/test.mp4".to_string(),
-            1024,
-            "hash123".to_string(),
-            crate::data::models::material::MaterialType::Video,
-            Some("model_id".to_string()),
-        );
-
-        assert_eq!(material.model_id, Some("model_id".to_string()));
-    }
-}
diff --git a/apps/desktop/src-tauri/src/tests/mod.rs b/apps/desktop/src-tauri/src/tests/mod.rs
deleted file mode 100644
index 3e9b923..0000000
--- a/apps/desktop/src-tauri/src/tests/mod.rs
+++ /dev/null
@@ -1,11 +0,0 @@
-/// 测试模块
-/// 遵循 Tauri 开发规范的测试组织结构
-
-pub mod material_tests;
-pub mod project_template_binding_tests;
-pub mod material_model_binding_tests;
-
-/// 集成测试模块
-pub mod integration {
-    pub mod binding_management_integration_tests;
-}
diff --git a/apps/desktop/src-tauri/src/tests/project_template_binding_tests.rs b/apps/desktop/src-tauri/src/tests/project_template_binding_tests.rs
deleted file mode 100644
index 35940a1..0000000
--- a/apps/desktop/src-tauri/src/tests/project_template_binding_tests.rs
+++ /dev/null
@@ -1,379 +0,0 @@
-/**
- * 项目-模板绑定功能测试
- * 遵循 Tauri 开发规范的测试设计原则
- */
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-    use crate::data::models::project_template_binding::{
-        ProjectTemplateBinding, BindingType, BindingStatus,
-        CreateProjectTemplateBindingRequest, UpdateProjectTemplateBindingRequest,
-        ProjectTemplateBindingQueryParams, BatchCreateProjectTemplateBindingRequest,
-    };
-    use crate::data::repositories::project_template_binding_repository::ProjectTemplateBindingRepository;
-    use crate::business::services::project_template_binding_service::ProjectTemplateBindingService;
-    use crate::infrastructure::database::Database;
-    use std::sync::{Arc, Mutex};
-    use uuid::Uuid;
-
-    /// 创建测试数据库连接
-    fn create_test_database() -> Arc<Mutex<rusqlite::Connection>> {
-        let conn = rusqlite::Connection::open_in_memory().unwrap();
-        
-        // 创建项目-模板绑定表
-        conn.execute(
-            "CREATE TABLE project_template_bindings (
-                id TEXT PRIMARY KEY,
-                project_id TEXT NOT NULL,
-                template_id TEXT NOT NULL,
-                binding_name TEXT,
-                description TEXT,
-                priority INTEGER DEFAULT 0,
-                is_active INTEGER DEFAULT 1,
-                binding_type TEXT NOT NULL,
-                binding_status TEXT NOT NULL,
-                metadata TEXT,
-                created_at DATETIME DEFAULT CURRENT_TIMESTAMP,
-                updated_at DATETIME DEFAULT CURRENT_TIMESTAMP,
-                UNIQUE (project_id, template_id)
-            )",
-            [],
-        ).unwrap();
-
-        Arc::new(Mutex::new(conn))
-    }
-
-    /// 创建测试绑定请求
-    fn create_test_binding_request() -> CreateProjectTemplateBindingRequest {
-        CreateProjectTemplateBindingRequest {
-            project_id: Uuid::new_v4().to_string(),
-            template_id: Uuid::new_v4().to_string(),
-            binding_name: Some("测试绑定".to_string()),
-            description: Some("这是一个测试绑定".to_string()),
-            priority: Some(1),
-            binding_type: BindingType::Primary,
-        }
-    }
-
-    #[test]
-    fn test_create_project_template_binding() {
-        let conn = create_test_database();
-        let repository = ProjectTemplateBindingRepository::new(conn);
-        let request = create_test_binding_request();
-
-        let result = repository.create(request.clone());
-        assert!(result.is_ok());
-
-        let binding = result.unwrap();
-        assert_eq!(binding.project_id, request.project_id);
-        assert_eq!(binding.template_id, request.template_id);
-        assert_eq!(binding.binding_name, request.binding_name);
-        assert_eq!(binding.description, request.description);
-        assert_eq!(binding.priority, request.priority.unwrap());
-        assert_eq!(binding.binding_type, request.binding_type);
-        assert_eq!(binding.binding_status, BindingStatus::Active);
-        assert!(binding.is_active);
-    }
-
-    #[test]
-    fn test_get_binding_by_id() {
-        let conn = create_test_database();
-        let repository = ProjectTemplateBindingRepository::new(conn);
-        let request = create_test_binding_request();
-
-        // 创建绑定
-        let created_binding = repository.create(request).unwrap();
-
-        // 获取绑定
-        let result = repository.get_by_id(&created_binding.id);
-        assert!(result.is_ok());
-
-        let binding = result.unwrap();
-        assert!(binding.is_some());
-        let binding = binding.unwrap();
-        assert_eq!(binding.id, created_binding.id);
-        assert_eq!(binding.project_id, created_binding.project_id);
-        assert_eq!(binding.template_id, created_binding.template_id);
-    }
-
-    #[test]
-    fn test_update_binding() {
-        let conn = create_test_database();
-        let repository = ProjectTemplateBindingRepository::new(conn);
-        let request = create_test_binding_request();
-
-        // 创建绑定
-        let created_binding = repository.create(request).unwrap();
-
-        // 更新绑定
-        let update_request = UpdateProjectTemplateBindingRequest {
-            binding_name: Some("更新后的绑定名称".to_string()),
-            description: Some("更新后的描述".to_string()),
-            priority: Some(5),
-            binding_type: Some(BindingType::Secondary),
-            binding_status: Some(BindingStatus::Paused),
-            is_active: Some(false),
-        };
-
-        let result = repository.update(&created_binding.id, update_request);
-        assert!(result.is_ok());
-
-        let updated_binding = result.unwrap();
-        assert!(updated_binding.is_some());
-        let updated_binding = updated_binding.unwrap();
-        assert_eq!(updated_binding.binding_name, Some("更新后的绑定名称".to_string()));
-        assert_eq!(updated_binding.description, Some("更新后的描述".to_string()));
-        assert_eq!(updated_binding.priority, 5);
-        assert_eq!(updated_binding.binding_type, BindingType::Secondary);
-        assert_eq!(updated_binding.binding_status, BindingStatus::Paused);
-        assert!(!updated_binding.is_active);
-    }
-
-    #[test]
-    fn test_delete_binding() {
-        let conn = create_test_database();
-        let repository = ProjectTemplateBindingRepository::new(conn);
-        let request = create_test_binding_request();
-
-        // 创建绑定
-        let created_binding = repository.create(request).unwrap();
-
-        // 删除绑定
-        let result = repository.delete(&created_binding.id);
-        assert!(result.is_ok());
-        assert!(result.unwrap());
-
-        // 验证绑定已被删除
-        let get_result = repository.get_by_id(&created_binding.id);
-        assert!(get_result.is_ok());
-        assert!(get_result.unwrap().is_none());
-    }
-
-    #[test]
-    fn test_list_bindings_with_filters() {
-        let conn = create_test_database();
-        let repository = ProjectTemplateBindingRepository::new(conn);
-        let project_id = Uuid::new_v4().to_string();
-
-        // 创建多个绑定
-        let requests = vec![
-            CreateProjectTemplateBindingRequest {
-                project_id: project_id.clone(),
-                template_id: Uuid::new_v4().to_string(),
-                binding_name: Some("主要绑定".to_string()),
-                description: None,
-                priority: Some(0),
-                binding_type: BindingType::Primary,
-            },
-            CreateProjectTemplateBindingRequest {
-                project_id: project_id.clone(),
-                template_id: Uuid::new_v4().to_string(),
-                binding_name: Some("次要绑定".to_string()),
-                description: None,
-                priority: Some(1),
-                binding_type: BindingType::Secondary,
-            },
-            CreateProjectTemplateBindingRequest {
-                project_id: Uuid::new_v4().to_string(), // 不同项目
-                template_id: Uuid::new_v4().to_string(),
-                binding_name: Some("其他项目绑定".to_string()),
-                description: None,
-                priority: Some(0),
-                binding_type: BindingType::Primary,
-            },
-        ];
-
-        for request in requests {
-            repository.create(request).unwrap();
-        }
-
-        // 测试按项目ID过滤
-        let query_params = ProjectTemplateBindingQueryParams {
-            project_id: Some(project_id.clone()),
-            template_id: None,
-            binding_type: None,
-            binding_status: None,
-            is_active: None,
-            limit: None,
-            offset: None,
-        };
-
-        let result = repository.list(query_params);
-        assert!(result.is_ok());
-        let bindings = result.unwrap();
-        assert_eq!(bindings.len(), 2);
-
-        // 验证排序（按优先级排序）
-        assert_eq!(bindings[0].priority, 0);
-        assert_eq!(bindings[1].priority, 1);
-
-        // 测试按绑定类型过滤
-        let query_params = ProjectTemplateBindingQueryParams {
-            project_id: Some(project_id),
-            template_id: None,
-            binding_type: Some(BindingType::Primary),
-            binding_status: None,
-            is_active: None,
-            limit: None,
-            offset: None,
-        };
-
-        let result = repository.list(query_params);
-        assert!(result.is_ok());
-        let bindings = result.unwrap();
-        assert_eq!(bindings.len(), 1);
-        assert_eq!(bindings[0].binding_type, BindingType::Primary);
-    }
-
-    #[test]
-    fn test_batch_create_bindings() {
-        let conn = create_test_database();
-        let repository = ProjectTemplateBindingRepository::new(conn);
-        let project_id = Uuid::new_v4().to_string();
-        let template_ids = vec![
-            Uuid::new_v4().to_string(),
-            Uuid::new_v4().to_string(),
-            Uuid::new_v4().to_string(),
-        ];
-
-        let request = BatchCreateProjectTemplateBindingRequest {
-            project_id: project_id.clone(),
-            template_ids: template_ids.clone(),
-            binding_type: BindingType::Secondary,
-            priority_start: Some(10),
-        };
-
-        let result = repository.batch_create(request);
-        assert!(result.is_ok());
-        let bindings = result.unwrap();
-        assert_eq!(bindings.len(), 3);
-
-        // 验证优先级递增
-        for (i, binding) in bindings.iter().enumerate() {
-            assert_eq!(binding.project_id, project_id);
-            assert_eq!(binding.template_id, template_ids[i]);
-            assert_eq!(binding.binding_type, BindingType::Secondary);
-            assert_eq!(binding.priority, 10 + i as u32);
-        }
-    }
-
-    #[test]
-    fn test_binding_exists() {
-        let conn = create_test_database();
-        let repository = ProjectTemplateBindingRepository::new(conn);
-        let request = create_test_binding_request();
-
-        // 绑定不存在时
-        let result = repository.exists(&request.project_id, &request.template_id);
-        assert!(result.is_ok());
-        assert!(!result.unwrap());
-
-        // 创建绑定
-        repository.create(request.clone()).unwrap();
-
-        // 绑定存在时
-        let result = repository.exists(&request.project_id, &request.template_id);
-        assert!(result.is_ok());
-        assert!(result.unwrap());
-    }
-
-    #[test]
-    fn test_unique_constraint() {
-        let conn = create_test_database();
-        let repository = ProjectTemplateBindingRepository::new(conn);
-        let request = create_test_binding_request();
-
-        // 第一次创建应该成功
-        let result1 = repository.create(request.clone());
-        assert!(result1.is_ok());
-
-        // 第二次创建相同的项目-模板绑定应该失败
-        let result2 = repository.create(request);
-        assert!(result2.is_err());
-    }
-
-    #[tokio::test]
-    async fn test_business_service_create_binding() {
-        let conn = create_test_database();
-        let service = ProjectTemplateBindingService::new(conn).unwrap();
-        let request = create_test_binding_request();
-
-        let result = service.create_binding(request.clone()).await;
-        assert!(result.is_ok());
-
-        let binding = result.unwrap();
-        assert_eq!(binding.project_id, request.project_id);
-        assert_eq!(binding.template_id, request.template_id);
-    }
-
-    #[tokio::test]
-    async fn test_business_service_prevent_duplicate_primary() {
-        let conn = create_test_database();
-        let service = ProjectTemplateBindingService::new(conn).unwrap();
-        let project_id = Uuid::new_v4().to_string();
-
-        // 创建第一个主要绑定
-        let request1 = CreateProjectTemplateBindingRequest {
-            project_id: project_id.clone(),
-            template_id: Uuid::new_v4().to_string(),
-            binding_name: Some("第一个主要绑定".to_string()),
-            description: None,
-            priority: Some(0),
-            binding_type: BindingType::Primary,
-        };
-
-        let result1 = service.create_binding(request1).await;
-        assert!(result1.is_ok());
-
-        // 尝试创建第二个主要绑定应该失败
-        let request2 = CreateProjectTemplateBindingRequest {
-            project_id: project_id.clone(),
-            template_id: Uuid::new_v4().to_string(),
-            binding_name: Some("第二个主要绑定".to_string()),
-            description: None,
-            priority: Some(0),
-            binding_type: BindingType::Primary,
-        };
-
-        let result2 = service.create_binding(request2).await;
-        assert!(result2.is_err());
-    }
-
-    #[test]
-    fn test_binding_validation() {
-        let mut binding = ProjectTemplateBinding::new(
-            "project_id".to_string(),
-            "template_id".to_string(),
-            BindingType::Primary,
-        );
-
-        // 有效的绑定应该通过验证
-        assert!(binding.validate().is_ok());
-
-        // 空的项目ID应该失败
-        binding.project_id = "".to_string();
-        assert!(binding.validate().is_err());
-
-        // 重置项目ID
-        binding.project_id = "project_id".to_string();
-
-        // 空的模板ID应该失败
-        binding.template_id = "".to_string();
-        assert!(binding.validate().is_err());
-
-        // 重置模板ID
-        binding.template_id = "template_id".to_string();
-
-        // 过长的绑定名称应该失败
-        binding.binding_name = Some("a".repeat(101));
-        assert!(binding.validate().is_err());
-
-        // 重置绑定名称
-        binding.binding_name = Some("正常名称".to_string());
-
-        // 过长的描述应该失败
-        binding.description = Some("a".repeat(501));
-        assert!(binding.validate().is_err());
-    }
-}
diff --git a/apps/desktop/src-tauri/tauri.conf.json b/apps/desktop/src-tauri/tauri.conf.json
index 32feebf..a88b953 100644
--- a/apps/desktop/src-tauri/tauri.conf.json
+++ b/apps/desktop/src-tauri/tauri.conf.json
@@ -25,7 +25,11 @@
       }
     ],
     "security": {
-      "csp": null
+      "csp": null,
+      "assetProtocol": {
+        "enable": true,
+        "scope": ["**"]
+      }
     }
   },
 
diff --git a/apps/desktop/src/components/MaterialSegmentView.tsx b/apps/desktop/src/components/MaterialSegmentView.tsx
index bf3d5fa..fd289d7 100644
--- a/apps/desktop/src/components/MaterialSegmentView.tsx
+++ b/apps/desktop/src/components/MaterialSegmentView.tsx
@@ -10,7 +10,7 @@ import {
   Trash2,
   FolderOpen
 } from 'lucide-react';
-import { invoke, convertFileSrc } from '@tauri-apps/api/core';
+import { invoke } from '@tauri-apps/api/core';
 import { SearchInput } from './InteractiveInput';
 import { InteractiveButton } from './InteractiveButton';
 
@@ -147,16 +147,22 @@ const ThumbnailDisplay: React.FC<ThumbnailDisplayProps> = ({
         setThumbnailUrl(thumbnailCache.get(segmentId) || null);
         return;
       }
-      console.log({ segment })
       // 首先检查数据库中是否已有缩略图
       if (segment.segment.thumbnail_path) {
-        // 去掉Windows长路径前缀 \\?\
-        const cleanPath = segment.segment.thumbnail_path.replace(/^\\\\\?\\/, '');
-        const thumbnailUrl = convertFileSrc(cleanPath);
-        setThumbnailUrl(thumbnailUrl);
-        // 更新缓存
-        setThumbnailCache(prev => new Map(prev.set(segmentId, thumbnailUrl)));
-        return;
+        try {
+          console.log('读取缩略图:', segment.segment.thumbnail_path);
+          const dataUrl = await invoke<string>('read_thumbnail_as_data_url', {
+            filePath: segment.segment.thumbnail_path
+          });
+          console.log('获取到数据URL');
+          setThumbnailUrl(dataUrl);
+          // 更新缓存
+          setThumbnailCache(prev => new Map(prev.set(segmentId, dataUrl)));
+          return;
+        } catch (error) {
+          console.error('读取缩略图失败:', error);
+          // 如果读取失败，继续生成新的缩略图
+        }
       }
 
       // 如果数据库中没有缩略图，则生成新的
@@ -164,14 +170,20 @@ const ThumbnailDisplay: React.FC<ThumbnailDisplayProps> = ({
       try {
         const thumbnailPath = await generateSegmentThumbnail(segment);
         if (thumbnailPath) {
-          // 去掉Windows长路径前缀 \\?\
-          const cleanPath = thumbnailPath.replace(/^\\\\\?\\/, '');
-          // 转换为可访问的URL
-          const thumbnailUrl = convertFileSrc(cleanPath);
-          setThumbnailUrl(thumbnailUrl);
+          try {
+            console.log('生成的缩略图路径:', thumbnailPath);
+            const cleanPath = thumbnailPath.replace(/^\\\\\?\\/, '');
+            const dataUrl = await invoke<string>('read_thumbnail_as_data_url', {
+              filePath: cleanPath
+            });
+            console.log('转换为数据URL成功');
+            setThumbnailUrl(dataUrl);
 
-          // 更新缓存
-          setThumbnailCache(prev => new Map(prev.set(segmentId, thumbnailUrl)));
+            // 更新缓存
+            setThumbnailCache(prev => new Map(prev.set(segmentId, dataUrl)));
+          } catch (error) {
+            console.error('读取生成的缩略图失败:', error);
+          }
         }
       } catch (error) {
         console.error('加载缩略图失败:', error);