fix: lifecycle problem

Author: DataEraserC

file_classification_cli/src/bin/file_classification_cli.rs

@@ -716,8 +716,8 @@ fn handle_command(command: Cli, conn: &mut AnyConnection, context: &mut Context)
                 });
 
                 let dto = CreateFileDTO {
-                    type_: &type_,
-                    path: &path,
+                    type_,
+                    path,
                     group_id,
                 };
                 match files::create_file(conn, dto) {

file_classification_core/src/model/models.rs

@@ -20,9 +20,9 @@ pub struct File {
 
 #[derive(Insertable)]
 #[diesel(table_name = files)]
-pub struct CreateFileDTO<'a, 'b> {
-    pub type_: &'a str,
-    pub path: &'b str,
+pub struct CreateFileDTO {
+    pub type_: String,
+    pub path: String,
     pub group_id: i32,
 }
 
@@ -119,12 +119,13 @@ pub struct Group {
     pub modify_time: chrono::NaiveDateTime,
 }
 
-#[derive(Insertable)]
+#[derive(Insertable, Deserialize, Serialize)]
 #[diesel(table_name = groups)]
-pub struct CreateGroupDTO<'a> {
-    pub name: &'a str,
+pub struct CreateGroupDTO {
+    pub name: String,
 }
 
+
 #[derive(Deserialize,Clone)]
 pub enum GroupCondition {
     Id(i32),
@@ -241,10 +242,10 @@ pub struct Tag {
     pub reference_count: i32,
 }
 
-#[derive(Insertable)]
+#[derive(Insertable, Deserialize, Serialize)]
 #[diesel(table_name = tags)]
-pub struct CreateTagDTO<'a> {
-    pub name: &'a str,
+pub struct CreateTagDTO {
+    pub name: String,
 }
 
 #[derive(Deserialize, Clone)]

file_classification_core/src/service/files.rs

@@ -8,13 +8,21 @@ use crate::{internal, service};
 use diesel::Connection;
 use crate::utils::database::AnyConnection;
 
-pub fn raw_create_file(
+pub fn raw_create_file<S1, S2>(
     conn: &mut AnyConnection,
-    type_: &str,
-    path_: &str,
+    type_: S1,
+    path_: S2,
     group_id: i32,
-) -> Result<usize, diesel::result::Error> {
-    let new_file = CreateFileDTO { type_, path: path_, group_id };
+) -> Result<usize, diesel::result::Error>
+where
+    S1: Into<String>,
+    S2: Into<String>,
+{
+    let new_file = CreateFileDTO {
+        type_: type_.into(),
+        path: path_.into(),
+        group_id
+    };
     internal::files::create_file(conn, &new_file)
 }
 // pub fn create_file(

file_classification_core/src/service/groups.rs

@@ -5,10 +5,14 @@ use diesel::result::Error;
 use diesel::{Connection, JoinOnDsl};
 use crate::utils::database::AnyConnection;
 
-pub fn create_group_by_name(conn: &mut AnyConnection, name: &str) -> Result<usize, Error> {
-    let new_group = CreateGroupDTO { name };
+pub fn create_group_by_name<S>(conn: &mut AnyConnection, name: S) -> Result<usize, Error>
+where
+    S: Into<String>,
+{
+    let new_group = CreateGroupDTO { name: name.into() };
     groups::create_group(conn, &new_group)
 }
+
 pub fn create_group(conn: &mut AnyConnection, create_group_dTO: &CreateGroupDTO) -> Result<usize, Error> {
     groups::create_group(conn, create_group_dTO)
 }

file_classification_core/src/service/tags.rs

@@ -6,8 +6,11 @@ use crate::{
 use diesel::{Connection, JoinOnDsl};
 use crate::utils::database::AnyConnection;
 
-pub fn create_tag_by_name(conn: &mut AnyConnection, name: &str) -> Result<Tag, diesel::result::Error> {
-    let new_tag = CreateTagDTO { name };
+pub fn create_tag_by_name<S>(conn: &mut AnyConnection, name: S) -> Result<Tag, diesel::result::Error>
+where
+    S: Into<String>,
+{
+    let new_tag = CreateTagDTO { name: name.into() };
     tags::create_tag(conn, &new_tag)
 }
 

file_classification_webapi/src/bin/handlers/files.rs

@@ -1,9 +1,8 @@
 use actix_web::{get, post, put, delete, web, HttpResponse, Result};
 use serde_json::json;
 use file_classification_core::{model::models::{FileCondition, UpdateFileDTO, FileFilter}, service::files::{select_files, select_files_by_conditions, update_files_by_conditions, delete_file}, utils};
-use file_classification_core::service::files::create_file;
-use crate::utils::database::{DbPool, DbPooledConnection};
-use crate::utils::models::{ApiResponse, ApiError, CreateFileDTO};
+use crate::utils::database::{DbPool};
+use crate::utils::models::{ApiResponse, ApiError};
 
 #[get("/api/files")]
 async fn api_list_files(

file_classification_webapi/src/bin/handlers/group_tags.rs

@@ -2,8 +2,8 @@ use actix_web::{get, post, delete, web, HttpResponse, Result};
 use serde_json::json;
 use file_classification_core::{model::models::GroupTagCondition, service::group_tag::{select_group_tags_by_conditions, create_group_tag, delete_group_tag_by_id}, utils};
 use file_classification_core::model::models::GroupTagDTO;
-use crate::utils::database::{DbPool, DbPooledConnection};
-use crate::utils::models::{CreateGroupTagDTO, ApiResponse, ApiError};
+use crate::utils::database::{DbPool};
+use crate::utils::models::{ ApiResponse, ApiError};
 
 #[get("/api/group-tags")]
 async fn api_list_group_tags_by_conditions(

file_classification_webapi/src/bin/handlers/groups.rs

@@ -2,7 +2,7 @@ use actix_web::{get, post, put, delete, web, HttpResponse, Result};
 use serde_json::json;
 use file_classification_core::{model::models::{GroupCondition, UpdateGroupDTO, GroupFilter}, service::groups::{select_groups, select_groups_by_conditions, create_group, update_groups_by_conditions, delete_group}, utils};
 use crate::utils::database::{DbPool, DbPooledConnection};
-use crate::utils::models::{CreateGroupDTO, ApiResponse, ApiError};
+use crate::utils::models::{ApiResponse, ApiError};
 
 #[get("/api/groups")]
 async fn api_list_groups(
@@ -52,11 +52,12 @@ async fn api_list_groups_by_conditions(
 
 #[post("/api/groups")]
 async fn api_create_group(
-    group_dto: web::Json<CreateGroupDTO>,
+    payload: web::Json<file_classification_core::model::models::CreateGroupDTO>,
     pool: web::Data<DbPool>,
 ) -> Result<HttpResponse> {
     let mut conn = pool.get().expect("Failed to get connection from pool");
-    match create_group(&mut conn, &group_dto.name) {
+    let group_dto = payload.into_inner();
+    match create_group(&mut conn, &group_dto) {
         Ok(group) => Ok(HttpResponse::Created().json(ApiResponse::from(group))),
         Err(e) => Ok(HttpResponse::InternalServerError().json(ApiError {
             success: false,

file_classification_webapi/src/bin/handlers/tags.rs

@@ -1,8 +1,9 @@
 use actix_web::{get, post, put, delete, web, HttpResponse, Result};
 use serde_json::json;
 use file_classification_core::{model::models::{TagCondition, UpdateTagDTO, TagFilter}, service::tags::{select_tags, select_tags_by_conditions, create_tag, update_tags_by_conditions, delete_tag}, utils};
+use file_classification_core::model::models::CreateTagDTO;
 use crate::utils::database::{DbPool, DbPooledConnection};
-use crate::utils::models::{CreateTagDTO, ApiResponse, ApiError};
+use crate::utils::models::{ApiResponse, ApiError};
 
 #[get("/api/tags")]
 async fn api_list_tags(
@@ -52,11 +53,12 @@ async fn api_list_tags_by_conditions(
 
 #[post("/api/tags")]
 async fn api_create_tag(
-    tag_dto: web::Json<CreateTagDTO>,
+    payload: web::Json<CreateTagDTO>,
     pool: web::Data<DbPool>,
 ) -> Result<HttpResponse> {
     let mut conn = pool.get().expect("Failed to get connection from pool");
-    match create_tag(&mut conn, &tag_dto.name) {
+    let tag_dto = payload.into_inner();
+    match create_tag(&mut conn, &tag_dto) {
         Ok(tag) => Ok(HttpResponse::Created().json(ApiResponse::from(tag))),
         Err(e) => Ok(HttpResponse::InternalServerError().json(ApiError {
             success: false,

file_classification_webapi/src/bin/utils/models.rs

@@ -3,92 +3,6 @@
 use serde::{Deserialize, Serialize};
 use chrono::{NaiveDateTime, serde::ts_seconds_option};
 
-// File 相关 DTO
-#[derive(Debug, Serialize, Deserialize)]
-pub struct CreateFileDTO {
-    pub type_: String,
-    pub path: String,
-    pub group_id: i32,
-}
-
-#[derive(Debug, Serialize, Deserialize)]
-pub struct UpdateFileDTO {
-    pub path: Option<String>,
-    pub type_: Option<String>,
-    pub reference_count: Option<i32>,
-    pub group_id: Option<i32>,
-}
-
-#[derive(Debug, Serialize, Deserialize)]
-pub struct FileFilter {
-    pub id: Option<i32>,
-    pub type_: Option<String>,
-    pub path: Option<String>,
-    pub reference_count: Option<i32>,
-    pub group_id: Option<i32>,
-}
-
-// Group 相关 DTO
-#[derive(Debug, Serialize, Deserialize)]
-pub struct CreateGroupDTO {
-    pub name: String,
-}
-
-#[derive(Debug, Serialize, Deserialize)]
-pub struct UpdateGroupDTO {
-    pub name: Option<String>,
-    pub reference_count: Option<i32>,
-    pub is_primary: Option<bool>,
-    pub click_count: Option<i32>,
-    pub share_count: Option<i32>,
-    pub create_time: Option<NaiveDateTime>,
-    pub modify_time: Option<NaiveDateTime>,
-}
-
-#[derive(Debug, Serialize, Deserialize)]
-pub struct GroupFilter {
-    pub id: Option<i32>,
-    pub name: Option<String>,
-    pub reference_count: Option<i32>,
-    pub is_primary: Option<bool>,
-    pub click_count: Option<i32>,
-    pub share_count: Option<i32>,
-    pub create_time: Option<NaiveDateTime>,
-    pub modify_time: Option<NaiveDateTime>,
-}
-
-// Tag 相关 DTO
-#[derive(Debug, Serialize, Deserialize)]
-pub struct CreateTagDTO {
-    pub name: String,
-}
-
-#[derive(Debug, Serialize, Deserialize)]
-pub struct UpdateTagDTO {
-    pub name: Option<String>,
-    pub reference_count: Option<i32>,
-}
-
-#[derive(Debug, Serialize, Deserialize)]
-pub struct TagFilter {
-    pub id: Option<i32>,
-    pub name: Option<String>,
-    pub reference_count: Option<i32>,
-}
-
-// FileGroup 相关 DTO
-#[derive(Debug, Serialize, Deserialize)]
-pub struct CreateFileGroupDTO {
-    pub file_id: i32,
-    pub group_id: i32,
-}
-
-// GroupTag 相关 DTO
-#[derive(Debug, Serialize, Deserialize)]
-pub struct CreateGroupTagDTO {
-    pub group_id: i32,
-    pub tag_id: i32,
-}
 
 // 通用响应结构
 #[derive(Debug, Serialize)]