snapshot

Author: DataEraserC

Cargo.lock

@@ -1,6 +1,7 @@
 use file_classification_core::service::file_group::create_file_group;
 use file_classification_core::utils::database::establish_connection;
 use std::io::{stdin, stdout, Write};
+use file_classification_core::model::models::FileGroupDTO;
 
 fn main() {
     let connection = &mut establish_connection();
@@ -18,7 +19,7 @@ fn main() {
     stdin().read_line(&mut group_id_input).unwrap();
     let group_id: i32 = group_id_input.trim().parse().expect("Invalid Group ID");
 
-    let result = create_file_group(connection, file_id, group_id);
+    let result = create_file_group(connection, FileGroupDTO{ file_id, group_id});
     match result {
         Ok(new_file_group) => {
             println!("FileGroup created successfully!(NewFileGroup<{:?}>)", new_file_group)

file_classification_cli/src/bin/create_file_group.rs

@@ -1,6 +1,7 @@
 use file_classification_core::service::group_tag::create_group_tag;
 use file_classification_core::utils::database::establish_connection;
 use std::io::{stdin, stdout, Write};
+use file_classification_core::model::models::GroupTagDTO;
 
 fn main() {
     let connection = &mut establish_connection();
@@ -18,7 +19,7 @@ fn main() {
     stdin().read_line(&mut tag_id_input).unwrap();
     let tag_id: i32 = tag_id_input.trim().parse().expect("Invalid Tag ID");
 
-    let result = create_group_tag(connection, group_id, tag_id);
+    let result = create_group_tag(connection, GroupTagDTO{group_id, tag_id});
     match result {
         Ok(new_group_tag) => {
             println!("GroupTag created successfully!(GroupTag<{:?}>)", new_group_tag)

file_classification_cli/src/bin/create_group_tag.rs

@@ -1,6 +1,7 @@
 use file_classification_core::service::file_group::delete_file_group;
 use file_classification_core::utils::database::establish_connection;
 use std::io::{stdin, stdout, Write};
+use file_classification_core::model::models::FileGroupDTO;
 
 fn main() {
     let connection = &mut establish_connection();
@@ -18,7 +19,7 @@ fn main() {
     stdin().read_line(&mut group_id_input).unwrap();
     let group_id: i32 = group_id_input.trim().parse().expect("Invalid Group ID");
 
-    let result = delete_file_group(connection, file_id, group_id);
+    let result = delete_file_group(connection, FileGroupDTO{file_id, group_id});
     match result {
         Ok(deleted_file_group_num) => {
             if deleted_file_group_num == 0 {

file_classification_cli/src/bin/delete_file_group.rs

@@ -1,6 +1,7 @@
 use file_classification_core::service::group_tag::delete_group_tag;
 use file_classification_core::utils::database::establish_connection;
 use std::io::{stdin, stdout, Write};
+use file_classification_core::model::models::GroupTagDTO;
 
 fn main() {
     let connection = &mut establish_connection();
@@ -18,7 +19,7 @@ fn main() {
     stdin().read_line(&mut tag_id_input).unwrap();
     let tag_id: i32 = tag_id_input.trim().parse().expect("Invalid Tag ID");
 
-    let result = delete_group_tag(connection, group_id, tag_id);
+    let result = delete_group_tag(connection, GroupTagDTO{group_id, tag_id});
     match result {
         Ok(deleted_group_tag_num) => {
             if deleted_group_tag_num == 0 {

file_classification_cli/src/bin/delete_group_tag.rs

@@ -7,6 +7,7 @@ edition = "2024"
 diesel = { workspace = true }
 dotenvy = { workspace = true }
 chrono = { workspace = true }
+serde = { version = "1.0.219", features = ["derive"] }
 #mysqlclient-sys = { workspace = true }
 #libsqlite3-sys = { workspace = true }
 #openssl-sys = { workspace = true }

file_classification_core/Cargo.toml

@@ -9,40 +9,37 @@ use std::fmt::{Debug, Formatter, Result as fmtResult};
 
 pub fn create_file_group(
     conn: &mut SqliteConnection,
-    file_id: i32,
-    group_id: i32,
+    file_group_dto: FileGroupDTO,
 ) -> Result<FileGroupDTO, AppError> {
-    let group = find_group_by_id(conn, group_id)?.ok_or(AppError::GroupNotFound)?;
+    let group = find_group_by_id(conn, file_group_dto.group_id)?.ok_or(AppError::GroupNotFound)?;
 
     if group.is_primary {
         return Err(AppError::CannotAssociateWithPrimary);
     }
 
-    let new_file_group = FileGroupDTO { file_id, group_id };
     let result = conn.transaction::<_, AppError, _>(|conn| {
-        increase_file_reference_count(conn, file_id)?;
-        increase_group_reference_count(conn, group_id)?;
-        Ok(diesel::insert_into(file_groups::table).values(&new_file_group).execute(conn))
+        increase_file_reference_count(conn, file_group_dto.file_id)?;
+        increase_group_reference_count(conn, file_group_dto.group_id)?;
+        Ok(diesel::insert_into(file_groups::table).values(&file_group_dto).execute(conn))
     });
     let _ = result?;
-    Ok(new_file_group)
+    Ok(file_group_dto)
 }
 
 pub fn delete_file_group(
     conn: &mut SqliteConnection,
-    file_id: i32,
-    group_id: i32,
+    file_group_dto: FileGroupDTO,
 ) -> Result<usize, AppError> {
     let result = conn.transaction::<_, AppError, _>(|conn| {
         // 减少组和标签的引用计数
-        decrease_group_reference_count(conn, group_id)?;
-        decrease_file_reference_count(conn, file_id)?;
+        decrease_group_reference_count(conn, file_group_dto.group_id)?;
+        decrease_file_reference_count(conn, file_group_dto.file_id)?;
 
         // 删除关联记录
         let deleted_count = diesel::delete(
             file_groups::table
-                .filter(file_groups::group_id.eq(group_id))
-                .filter(file_groups::file_id.eq(file_id))
+                .filter(file_groups::group_id.eq(file_group_dto.group_id))
+                .filter(file_groups::file_id.eq(file_group_dto.file_id))
         )
             .execute(conn)?;
 

file_classification_core/src/internal/file_group.rs

@@ -4,6 +4,8 @@ use diesel::prelude::*;
 pub fn create_file(conn: &mut SqliteConnection, new_file: &CreateFileDTO) -> Result<File, AppError> {
     diesel::insert_into(files::table)
         .values(new_file)
+        // NOTE: as_returning 只有一部分数据库支持
+        // TODO: 若不支持则需要另外处理
         .returning(File::as_returning())
         .get_result(conn)
         .map_err(|e| AppError::CreateFileFailed(e.to_string()))
@@ -32,6 +34,7 @@ pub fn decrease_file_reference_count(
     Ok(())
 }
 
+#[deprecated]
 pub fn select_files(
     conn: &mut SqliteConnection,
     search_input: FileFilter,

file_classification_core/src/internal/files.rs

@@ -5,34 +5,31 @@ use std::fmt::{Debug, Formatter, Result as fmtResult};
 
 pub fn create_group_tag(
     conn: &mut SqliteConnection,
-    group_id: i32,
-    tag_id: i32,
+    group_tag_dto: GroupTagDTO
 ) -> Result<GroupTagDTO, AppError> {
-    let new_group_tag = GroupTagDTO { group_id, tag_id };
     let result = conn.transaction::<_, AppError, _>(|conn| {
-        increase_group_reference_count(conn, group_id)?;
-        increase_tag_reference_count(conn, tag_id)?;
-        Ok(diesel::insert_into(group_tags::table).values(&new_group_tag).execute(conn))
+        increase_group_reference_count(conn, group_tag_dto.group_id)?;
+        increase_tag_reference_count(conn, group_tag_dto.tag_id)?;
+        Ok(diesel::insert_into(group_tags::table).values(&group_tag_dto).execute(conn))
     });
     let _ = result?;
-    Ok(new_group_tag)
+    Ok(group_tag_dto)
 }
 
 pub fn delete_group_tag(
     conn: &mut SqliteConnection,
-    group_id: i32,
-    tag_id: i32,
+    group_tag_dto: GroupTagDTO
 ) -> Result<usize, AppError> {
     let result = conn.transaction::<_, AppError, _>(|conn| {
         // 减少组和标签的引用计数
-        decrease_group_reference_count(conn, group_id)?;
-        decrease_tag_reference_count(conn, tag_id)?;
+        decrease_group_reference_count(conn, group_tag_dto.group_id)?;
+        decrease_tag_reference_count(conn, group_tag_dto.tag_id)?;
 
         // 删除关联记录
         let deleted_count = diesel::delete(
             group_tags::table
-                .filter(group_tags::group_id.eq(group_id))
-                .filter(group_tags::tag_id.eq(tag_id))
+                .filter(group_tags::group_id.eq(group_tag_dto.group_id))
+                .filter(group_tags::tag_id.eq(group_tag_dto.tag_id))
         )
         .execute(conn)?;
 

file_classification_core/src/internal/group_tag.rs

@@ -47,6 +47,7 @@ pub fn mark_group_as_non_primary(conn: &mut SqliteConnection) -> Result<(), AppE
     Ok(())
 }
 
+#[deprecated]
 pub fn select_groups(
     conn: &mut SqliteConnection,
     search_input: GroupFilter,