snapshot

Author: DataEraserC

file_classification_core/src/service/file_group.rs

@@ -77,6 +77,27 @@ pub fn delete_file_groups_by_conditions(
     conn: &mut SqliteConnection,
     condition: Vec<FileGroupCondition>,
 ) -> Result<usize, Error> {
-    // TODO: 减少文件和组的引用计数
-    crate::internal::file_group::delete_file_groups_by_conditions(conn, condition)
+    // 首先查询将要删除的记录
+    let file_groups_to_delete = select_file_groups_by_conditions(conn, condition.clone(), None)
+        .map_err(|e| match e {
+            diesel::result::Error::NotFound => Error::NotFound,
+            _ => e,
+        })?;
+
+    // 使用事务确保数据一致性
+    conn.transaction::<_, Error, _>(|conn| {
+        // 对于每个要删除的文件组关联，减少对应的文件和组的引用计数
+        for file_group in &file_groups_to_delete {
+            // 减少文件的引用计数
+            decrease_file_reference_count(conn, file_group.file_id)?;
+
+            // 减少组的引用计数
+            decrease_group_reference_count(conn, file_group.group_id)?;
+        }
+
+        // 执行实际的删除操作
+        let deleted_count = crate::internal::file_group::delete_file_groups_by_conditions(conn, condition)?;
+
+        Ok(deleted_count)
+    })
 }

file_classification_core/src/service/files.rs

@@ -155,7 +155,43 @@ pub fn delete_files_by_conditions(
     conn: &mut SqliteConnection,
     conditions: Vec<FileCondition>,
 ) -> Result<usize, diesel::result::Error> {
-    // TODO: 减少文件的引用计数
-    internal::files::delete_files_by_conditions(conn, conditions)
+    // 首先查询将要删除的文件
+    let files_to_delete = select_files_by_conditions(conn, conditions.clone(), None)
+        .map_err(|e| match e {
+            diesel::result::Error::NotFound => diesel::result::Error::NotFound,
+            _ => e,
+        })?;
+
+    // 使用事务确保数据一致性
+    conn.transaction::<_, diesel::result::Error, _>(|conn| {
+        let mut total_deleted = 0;
+
+        // 对于每个要删除的文件，处理相关的引用关系
+        for file in &files_to_delete {
+            // 查找与该文件关联的所有文件组关系
+            let file_groups = select_file_groups_by_conditions(
+                conn,
+                vec![FileGroupCondition::FileId(file.id)],
+                None,
+            )?;
+
+            // 对于每个文件组关系，减少对应组的引用计数
+            for file_group in &file_groups {
+                internal::groups::decrease_group_reference_count(conn, file_group.group_id)?;
+            }
+
+            // 删除与该文件关联的所有文件组关系
+            internal::file_group::delete_file_groups_by_conditions(
+                conn,
+                vec![FileGroupCondition::FileId(file.id)],
+            )?;
+
+            // 删除文件本身
+            let deleted_count = internal::files::delete_file_by_id(conn, file.id)?;
+            total_deleted += deleted_count;
+        }
+
+        Ok(total_deleted)
+    })
 }
 

file_classification_core/src/service/group_tag.rs

@@ -69,6 +69,27 @@ pub fn delete_group_tags_by_conditions(
     conn: &mut SqliteConnection,
     condition: Vec<GroupTagCondition>,
 ) -> Result<usize, Error> {
-    // TODO: 减少组和标签的引用计数
-    crate::internal::group_tag::delete_group_tags_by_conditions(conn, condition)
+    // 首先查询将要删除的组标签关联
+    let group_tags_to_delete = select_group_tags_by_conditions(conn, condition.clone(), None)
+        .map_err(|e| match e {
+            diesel::result::Error::NotFound => diesel::result::Error::NotFound,
+            _ => e,
+        })?;
+
+    // 使用事务确保数据一致性
+    conn.transaction::<_, Error, _>(|conn| {
+        // 对于每个要删除的组标签关联，减少对应的组和标签的引用计数
+        for group_tag in &group_tags_to_delete {
+            // 减少组的引用计数
+            decrease_group_reference_count(conn, group_tag.group_id)?;
+
+            // 减少标签的引用计数
+            decrease_tag_reference_count(conn, group_tag.tag_id)?;
+        }
+
+        // 执行实际的删除操作
+        let deleted_count = crate::internal::group_tag::delete_group_tags_by_conditions(conn, condition)?;
+
+        Ok(deleted_count)
+    })
 }

file_classification_core/src/service/groups.rs

@@ -75,7 +75,45 @@ pub fn delete_groups_by_conditions(
     conn: &mut SqliteConnection,
     conditions: Vec<GroupCondition>,
 ) -> Result<usize, Error> {
-    // TODO: 减少组的引用计数
-    groups::delete_groups_by_conditions(conn, conditions)
+    // 首先查询将要删除的组
+    let groups_to_delete = select_groups_by_conditions(conn, conditions.clone(), None)
+        .map_err(|e| match e {
+            diesel::result::Error::NotFound => diesel::result::Error::NotFound,
+            _ => e,
+        })?;
+
+    // 使用事务确保数据一致性
+    conn.transaction::<_, Error, _>(|conn| {
+        let mut total_deleted = 0;
+
+        // 对于每个要删除的组，处理相关的引用关系和关联数据
+        for group in &groups_to_delete {
+            // 如果是主组，则删除相关的文件
+            if group.is_primary {
+                crate::internal::files::delete_files_by_conditions(
+                    conn,
+                    vec![FileCondition::GroupId(group.id)]
+                )?;
+            } else {
+                // 如果不是主组，则删除文件组关联
+                crate::internal::file_group::delete_file_groups_by_conditions(
+                    conn,
+                    vec![FileGroupCondition::GroupId(group.id)]
+                )?;
+            }
+
+            // 删除组标签关联
+            crate::internal::group_tag::delete_group_tags_by_conditions(
+                conn,
+                vec![GroupTagCondition::GroupId(group.id)]
+            )?;
+
+            // 删除组本身
+            let deleted_count = groups::delete_group(conn, group.id)?;
+            total_deleted += deleted_count;
+        }
+
+        Ok(total_deleted)
+    })
 }
 

file_classification_core/src/service/tags.rs

@@ -1,9 +1,9 @@
-use crate::model::models::{TagCondition, UpdateTagDTO};
+use crate::model::models::{GroupTagCondition, TagCondition, UpdateTagDTO};
 use crate::{
     internal::tags,
     model::models::{CreateTagDTO, Tag, TagFilter},
 };
-use diesel::SqliteConnection;
+use diesel::{Connection, SqliteConnection};
 
 pub fn create_tag(conn: &mut SqliteConnection, name: &str) -> Result<Tag, diesel::result::Error> {
     let new_tag = CreateTagDTO { name };
@@ -46,6 +46,30 @@ pub fn delete_tags_by_conditions(
     conn: &mut SqliteConnection,
     conditions: Vec<TagCondition>,
 ) -> Result<usize, diesel::result::Error> {
-    // TODO: 减少标签的引用计数
-    tags::delete_tags_by_conditions(conn, conditions)
-}
+    // 首先查询将要删除的标签
+    let tags_to_delete = select_tags_by_conditions(conn, conditions.clone(), None)
+        .map_err(|e| match e {
+            diesel::result::Error::NotFound => diesel::result::Error::NotFound,
+            _ => e,
+        })?;
+
+    // 使用事务确保数据一致性
+    conn.transaction::<_, diesel::result::Error, _>(|conn| {
+        let mut total_deleted = 0;
+
+        // 对于每个要删除的标签，处理相关的引用关系和关联数据
+        for tag in &tags_to_delete {
+            // 删除与该标签关联的所有组标签关系
+            crate::internal::group_tag::delete_group_tags_by_conditions(
+                conn,
+                vec![GroupTagCondition::TagId(tag.id)]
+            )?;
+
+            // 删除标签本身
+            let deleted_count = tags::delete_tag(conn, tag.id)?;
+            total_deleted += deleted_count;
+        }
+
+        Ok(total_deleted)
+    })
+}

file_classification_webapi/src/bin/utils/database.rs

@@ -18,8 +18,8 @@ pub type PooledConnection = r2d2::PooledConnection<ConnectionManager<SqliteConne
 //
 //     Arc::new(pool)
 // });
-
-// 获取连接的辅助函数
+//
+// // 获取连接的辅助函数
 // pub fn get_connection() -> Result<PooledConnection, r2d2::Error> {
 //     DB_POOL.get()
 // }