fix: process reference_count right

DataEraserC · DataEraserC · commit 71c566da5e0e · 2025-10-02T23:13:47.000+08:00
diff --git a/file_classification_core/src/internal/files.rs b/file_classification_core/src/internal/files.rs
@@ -257,3 +257,34 @@ pub fn delete_files_by_conditions(
 
     query.execute(conn)
 }
+pub fn increase_files_reference_count_by_conditions(
+    conn: &mut AnyConnection,
+    conditions: Vec<FileCondition>,
+) -> Result<usize, diesel::result::Error> {
+    let mut query = diesel::update(files::table).into_boxed::<<AnyConnection as Connection>::Backend>();
+
+    // 应用所有条件
+    for condition in conditions {
+        let boxed_condition = build_file_condition(condition);
+        query = query.filter(boxed_condition);
+    }
+
+    // 增加引用计数
+    query.set(files::reference_count.eq(files::reference_count + 1)).execute(conn)
+}
+
+pub fn decrease_files_reference_count_by_conditions(
+    conn: &mut AnyConnection,
+    conditions: Vec<FileCondition>,
+) -> Result<usize, diesel::result::Error> {
+    let mut query = diesel::update(files::table).into_boxed::<<AnyConnection as Connection>::Backend>();
+
+    // 应用所有条件
+    for condition in conditions {
+        let boxed_condition = build_file_condition(condition);
+        query = query.filter(boxed_condition);
+    }
+
+    // 减少引用计数
+    query.set(files::reference_count.eq(files::reference_count - 1)).execute(conn)
+}
diff --git a/file_classification_core/src/internal/groups.rs b/file_classification_core/src/internal/groups.rs
@@ -124,7 +124,6 @@ use super::models::GroupCondition;
 use crate::model::models::{GroupOrderBy, GroupQueryOptions, OrderDirection, UpdateGroupDTO};
 use diesel::dsl::not;
 use diesel::sql_types::Bool;
-use diesel::sqlite::Sqlite;
 use crate::utils::database::AnyConnection;
 
 // 将 GroupCondition 转换为 diesel 查询条件的辅助函数
@@ -325,3 +324,35 @@ pub fn delete_groups_by_conditions(
 
     query.execute(conn)
 }
+
+pub fn increase_groups_reference_count_by_conditions(
+    conn: &mut AnyConnection,
+    conditions: Vec<GroupCondition>,
+) -> Result<usize, diesel::result::Error> {
+    let mut query = diesel::update(groups::table).into_boxed::<<AnyConnection as Connection>::Backend>();
+
+    // 应用所有条件
+    for condition in conditions {
+        let boxed_condition = build_group_condition(condition);
+        query = query.filter(boxed_condition);
+    }
+
+    // 增加引用计数
+    query.set(groups::reference_count.eq(groups::reference_count + 1)).execute(conn)
+}
+
+pub fn decrease_groups_reference_count_by_conditions(
+    conn: &mut AnyConnection,
+    conditions: Vec<GroupCondition>,
+) -> Result<usize, diesel::result::Error> {
+    let mut query = diesel::update(groups::table).into_boxed::<<AnyConnection as Connection>::Backend>();
+
+    // 应用所有条件
+    for condition in conditions {
+        let boxed_condition = build_group_condition(condition);
+        query = query.filter(boxed_condition);
+    }
+
+    // 减少引用计数
+    query.set(groups::reference_count.eq(groups::reference_count - 1)).execute(conn)
+}
diff --git a/file_classification_core/src/internal/tags.rs b/file_classification_core/src/internal/tags.rs
@@ -248,3 +248,35 @@ pub fn delete_tags_by_conditions(
 
     query.execute(conn)
 }
+
+pub fn increase_tags_reference_count_by_conditions(
+    conn: &mut AnyConnection,
+    conditions: Vec<TagCondition>,
+) -> Result<usize, diesel::result::Error> {
+    let mut query = diesel::update(tags::table).into_boxed::<<AnyConnection as Connection>::Backend>();
+
+    // 应用所有条件
+    for condition in conditions {
+        let boxed_condition = build_tag_condition(condition);
+        query = query.filter(boxed_condition);
+    }
+
+    // 增加引用计数
+    query.set(tags::reference_count.eq(tags::reference_count + 1)).execute(conn)
+}
+
+pub fn decrease_tags_reference_count_by_conditions(
+    conn: &mut AnyConnection,
+    conditions: Vec<TagCondition>,
+) -> Result<usize, diesel::result::Error> {
+    let mut query = diesel::update(tags::table).into_boxed::<<AnyConnection as Connection>::Backend>();
+
+    // 应用所有条件
+    for condition in conditions {
+        let boxed_condition = build_tag_condition(condition);
+        query = query.filter(boxed_condition);
+    }
+
+    // 减少引用计数
+    query.set(tags::reference_count.eq(tags::reference_count - 1)).execute(conn)
+}
diff --git a/file_classification_core/src/service/file_group.rs b/file_classification_core/src/service/file_group.rs
@@ -7,6 +7,7 @@ use diesel::result::Error;
 use diesel::Connection;
 use crate::utils::database::AnyConnection;
 
+// 创建文件组关联(不允许使用于主组绑定)
 pub fn create_file_group(
     conn: &mut AnyConnection,
     file_group_dto: FileGroupDTO,
diff --git a/file_classification_core/src/service/files.rs b/file_classification_core/src/service/files.rs
@@ -1,9 +1,9 @@
 use crate::internal::file_group::select_file_groups_by_conditions;
 use crate::internal::groups::select_groups_by_conditions;
-use crate::model::models::{CreateFileDTO, File, FileCondition, FileFilter, FileGroupCondition, FileGroupDTO, GroupCondition, GroupTagCondition, UpdateFileDTO, UpdateGroupDTO};
+use crate::model::models::{CreateFileDTO, File, FileCondition, FileFilter, FileGroupCondition, FileGroupDTO, GroupCondition, GroupTagCondition, TagCondition, UpdateFileDTO, UpdateGroupDTO};
 use crate::service::groups::update_groups_by_conditions;
 use crate::service::AppError;
-use crate::utils::errors::AppError::CannotBindToPrimaryGroup;
+use crate::utils::errors::AppError::{FuturePrimaryGroupShouldBeEmpty};
 use crate::{internal, service};
 use diesel::Connection;
 use crate::utils::database::AnyConnection;
@@ -57,7 +57,7 @@ pub fn create_file(conn: &mut AnyConnection, create_file_dto: CreateFileDTO) ->
         )?;
 
         if file_groups.len() != 0 {
-            return Err(CannotBindToPrimaryGroup);
+            return Err(FuturePrimaryGroupShouldBeEmpty);
         }
         let mut count = 0;
         count += internal::files::create_file(conn, &create_file_dto)?;
@@ -100,20 +100,46 @@ pub fn delete_file(conn: &mut AnyConnection, file_id: i32) -> Result<(), AppErro
         let file_required_to_delete = internal::files::find_file_by_id(conn, file_id)?
             .ok_or_else(|| diesel::result::Error::NotFound)?;
 
-        // 删除与文件关联的组标签
+        // 查找与该文件关联的所有文件组关系（包括主组和其他组）
+        let file_groups = select_file_groups_by_conditions(
+            conn,
+            vec![FileGroupCondition::FileId(file_required_to_delete.id)],
+            None,
+        )?;
+
+        // 对于每个文件组关系，减少对应组的引用计数
+        for file_group in &file_groups {
+            internal::groups::decrease_group_reference_count(conn, file_group.group_id)?;
+        }
+
+        // 仅对主组关联的标签减少引用计数
+        let tag_list = internal::group_tag::select_group_tags_by_conditions(
+            conn,
+            vec![GroupTagCondition::GroupId(file_required_to_delete.group_id)],
+            None,
+        )?;
+
+        if !tag_list.is_empty() {
+            internal::tags::decrease_tags_reference_count_by_conditions(
+                conn,
+                vec![TagCondition::IdIn(tag_list.iter().map(|tag| tag.tag_id).collect::<Vec<_>>())],
+            )?;
+        }
+
+        // 删除与文件主组关联的所有组标签关系
         internal::group_tag::delete_group_tags_by_conditions(
             conn,
             vec![GroupTagCondition::GroupId(file_required_to_delete.group_id)],
         )?;
 
-        // 删除与文件关联的文件组关系
+        // 删除与文件关联的所有文件组关系
         internal::file_group::delete_file_groups_by_conditions(
             conn,
             vec![FileGroupCondition::FileId(file_required_to_delete.id)],
         )?;
 
-        // 删除组和文件本身
-        service::groups::delete_group(conn, file_required_to_delete.group_id)?;
+        // 删除主组和文件本身
+        internal::groups::delete_group(conn, file_required_to_delete.group_id)?;
         internal::files::delete_file_by_id(conn, file_id)?;
 
         Ok(())
@@ -168,7 +194,7 @@ pub fn delete_files_by_conditions(
 
         // 对于每个要删除的文件，处理相关的引用关系
         for file in &files_to_delete {
-            // 查找与该文件关联的所有文件组关系
+            // 查找与该文件关联的所有文件组关系（包括主组和其他组）
             let file_groups = select_file_groups_by_conditions(
                 conn,
                 vec![FileGroupCondition::FileId(file.id)],
@@ -180,13 +206,34 @@ pub fn delete_files_by_conditions(
                 internal::groups::decrease_group_reference_count(conn, file_group.group_id)?;
             }
 
+            // 仅对主组关联的标签减少引用计数
+            let tag_list = internal::group_tag::select_group_tags_by_conditions(
+                conn,
+                vec![GroupTagCondition::GroupId(file.group_id)],
+                None,
+            )?;
+
+            if !tag_list.is_empty() {
+                internal::tags::decrease_tags_reference_count_by_conditions(
+                    conn,
+                    vec![TagCondition::IdIn(tag_list.iter().map(|tag| tag.tag_id).collect::<Vec<_>>())],
+                )?;
+            }
+
+            // 删除与文件主组关联的所有组标签关系
+            internal::group_tag::delete_group_tags_by_conditions(
+                conn,
+                vec![GroupTagCondition::GroupId(file.group_id)],
+            )?;
+
             // 删除与该文件关联的所有文件组关系
             internal::file_group::delete_file_groups_by_conditions(
                 conn,
                 vec![FileGroupCondition::FileId(file.id)],
             )?;
 
-            // 删除文件本身
+            // 删除主组和文件本身
+            internal::groups::delete_group(conn, file.group_id)?;
             let deleted_count = internal::files::delete_file_by_id(conn, file.id)?;
             total_deleted += deleted_count;
         }
diff --git a/file_classification_core/src/service/groups.rs b/file_classification_core/src/service/groups.rs
@@ -22,25 +22,62 @@ pub fn delete_group(
     group_id: i32,
 ) -> Result<usize, Error> {
     // 1.判断是否是primary
-    // 若是primary 则直接删除对应的File，删除GroupTag
+    // 若是primary 则先删除对应的File，删除GroupTag，删除FileGroup
     // 若不是primary 则先删除GroupTag，再删除FileGroup
     conn.transaction::<usize, Error, _>(|conn| {
         let group = groups::find_group_by_id(conn, group_id)?.ok_or(AppError::GroupNotFound)?;
+
         if group.is_primary {
+            // 删除主组时，先处理关联的文件
             crate::internal::files::delete_files_by_conditions(conn, vec![
                 FileCondition::GroupId(group_id)
             ])?;
+
+            // 显式删除文件组关系（作为额外保障）
+            crate::internal::file_group::delete_file_groups_by_conditions(conn, vec![
+                FileGroupCondition::GroupId(group_id)
+            ])?;
         } else {
+            // 对于非主组，需要先减少关联文件的引用计数
+            let file_groups = crate::internal::file_group::select_file_groups_by_conditions(
+                conn,
+                vec![FileGroupCondition::GroupId(group_id)],
+                None,
+            )?;
+
+            // 减少每个关联文件的引用计数
+            for file_group in &file_groups {
+                crate::internal::files::decrease_file_reference_count(conn, file_group.file_id)?;
+            }
+
+            // 删除文件组关系
             crate::internal::file_group::delete_file_groups_by_conditions(conn, vec![
                 FileGroupCondition::GroupId(group_id)
             ])?;
         }
+
+        // 减少组关联标签的引用计数
+        let group_tags = crate::internal::group_tag::select_group_tags_by_conditions(
+            conn,
+            vec![GroupTagCondition::GroupId(group_id)],
+            None,
+        )?;
+
+        // 减少每个关联标签的引用计数
+        for group_tag in &group_tags {
+            crate::internal::tags::decrease_tag_reference_count(conn, group_tag.tag_id)?;
+        }
+
+        // 删除组标签关系
         crate::internal::group_tag::delete_group_tags_by_conditions(conn, vec![
             GroupTagCondition::GroupId(group_id)
         ])?;
+
+        // 最后删除组本身
         groups::delete_group(conn, group_id)
     })
 }
+
 #[allow(deprecated)]
 #[deprecated]
 pub fn select_groups(
@@ -94,22 +131,52 @@ pub fn delete_groups_by_conditions(
                     conn,
                     vec![FileCondition::GroupId(group.id)]
                 )?;
+
+                // 显式删除文件组关系（作为额外保障）
+                crate::internal::file_group::delete_file_groups_by_conditions(
+                    conn,
+                    vec![FileGroupCondition::GroupId(group.id)]
+                )?;
             } else {
-                // 如果不是主组，则删除文件组关联
+                // 如果不是主组，则先减少关联文件的引用计数
+                let file_groups = crate::internal::file_group::select_file_groups_by_conditions(
+                    conn,
+                    vec![FileGroupCondition::GroupId(group.id)],
+                    None,
+                )?;
+
+                // 减少每个关联文件的引用计数
+                for file_group in &file_groups {
+                    crate::internal::files::decrease_file_reference_count(conn, file_group.file_id)?;
+                }
+
+                // 删除文件组关联
                 crate::internal::file_group::delete_file_groups_by_conditions(
                     conn,
                     vec![FileGroupCondition::GroupId(group.id)]
                 )?;
             }
 
+            // 减少组关联标签的引用计数
+            let group_tags = crate::internal::group_tag::select_group_tags_by_conditions(
+                conn,
+                vec![GroupTagCondition::GroupId(group.id)],
+                None,
+            )?;
+
+            // 减少每个关联标签的引用计数
+            for group_tag in &group_tags {
+                crate::internal::tags::decrease_tag_reference_count(conn, group_tag.tag_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)?;
+            let deleted_count = crate::internal::groups::delete_group(conn, group.id)?;
             total_deleted += deleted_count;
         }
 
diff --git a/file_classification_core/src/service/tags.rs b/file_classification_core/src/service/tags.rs
diff --git a/file_classification_core/src/utils/errors.rs b/file_classification_core/src/utils/errors.rs
