rbum: move set cate (#825)

backend/basic/Cargo.toml

@@ -32,6 +32,7 @@ test = ["tardis/test"]
 [dependencies]
 serde.workspace = true
 async-trait.workspace = true
+async-recursion.workspace = true
 lazy_static.workspace = true
 itertools.workspace = true
 fancy-regex.workspace = true

backend/basic/src/rbum/dto/rbum_set_cate_dto.rs

@@ -83,6 +83,12 @@ pub struct RbumSetCateModifyReq {
     #[cfg_attr(feature = "default", oai(validator(min_length = "2", max_length = "1000")))]
     pub ext: Option<String>,
 
+    /// Parent node id
+    ///
+    /// 父节点id
+    #[cfg_attr(feature = "default", oai(validator(min_length = "2", max_length = "1000")))]
+    pub rbum_parent_cate_id: Option<String>,
+
     pub scope_level: Option<RbumScopeLevelKind>,
 }
 

backend/basic/src/rbum/dto/rbum_set_item_dto.rs

@@ -40,10 +40,15 @@ pub struct RbumSetItemAddReq {
 #[derive(Serialize, Deserialize, Debug)]
 #[cfg_attr(feature = "default", derive(poem_openapi::Object))]
 pub struct RbumSetItemModifyReq {
+    /// Associated [resource set category(node)](crate::rbum::dto::rbum_set_cate_dto::RbumSetCateDetailResp) id
+    ///
+    /// 关联[资源集分类（节点）](crate::rbum::dto::rbum_set_cate_dto::RbumSetCateDetailResp) id
+    #[cfg_attr(feature = "default", oai(validator(min_length = "2", max_length = "255")))]
+    pub rel_rbum_set_cate_id: Option<String>,
     /// Association sort
     ///
     /// 关联排序
-    pub sort: i64,
+    pub sort: Option<i64>,
 }
 
 /// Summary information of the association between resource set category(node) and resource item

backend/basic/src/rbum/serv/rbum_set_serv.rs

@@ -1,6 +1,7 @@
 use std::collections::{HashMap, HashSet};
 use std::time::Duration;
 
+use async_recursion::async_recursion;
 use async_trait::async_trait;
 use itertools::Itertools;
 use tardis::basic::dto::TardisContext;
@@ -342,7 +343,7 @@ impl RbumSetServ {
                         .iter()
                         .filter(|c| c.sys_code.starts_with(&cate.sys_code))
                         .flat_map(|c| items.get(&c.id).expect("ignore"))
-                        .group_by(|c| c.rel_rbum_item_kind_id.clone())
+                        .chunk_by(|c| c.rel_rbum_item_kind_id.clone())
                         .into_iter()
                         .map(|(g, c)| (g, c.map(|i| i.rel_rbum_item_id.clone()).collect::<HashSet<String>>().len() as u64))
                         .collect::<HashMap<String, u64>>(),
@@ -355,7 +356,7 @@ impl RbumSetServ {
             items
                 .values()
                 .flat_map(|item| item.iter())
-                .group_by(|c| c.rel_rbum_item_kind_id.clone())
+                .chunk_by(|c| c.rel_rbum_item_kind_id.clone())
                 .into_iter()
                 .map(|(g, c)| (g, c.map(|i| i.rel_rbum_item_id.clone()).collect::<HashSet<String>>().len() as u64))
                 .collect::<HashMap<String, u64>>(),
@@ -491,11 +492,23 @@ impl RbumCrudOperation<rbum_set_cate::ActiveModel, RbumSetCateAddReq, RbumSetCat
         })
     }
 
-    async fn package_modify(id: &str, modify_req: &RbumSetCateModifyReq, _: &TardisFunsInst, _: &TardisContext) -> TardisResult<rbum_set_cate::ActiveModel> {
+    async fn package_modify(id: &str, modify_req: &RbumSetCateModifyReq, funs: &TardisFunsInst, ctx: &TardisContext) -> TardisResult<rbum_set_cate::ActiveModel> {
         let mut rbum_set_cate = rbum_set_cate::ActiveModel {
             id: Set(id.to_string()),
             ..Default::default()
         };
+        if let Some(rbum_parent_cate_id) = &modify_req.rbum_parent_cate_id {
+            if let Some(detail) = Self::find_one_detail_rbum(&RbumSetCateFilterReq {
+                basic: RbumBasicFilterReq {
+                    ids: Some(vec![rbum_parent_cate_id.to_string()]),
+                    ..Default::default()
+                },
+                ..Default::default()
+            }, funs, ctx).await? {
+                let sys_code = Self::package_sys_code(&detail.rel_rbum_set_id, Some(rbum_parent_cate_id.as_str()), funs, ctx).await?;
+                rbum_set_cate.sys_code = Set(sys_code.to_string());
+            }
+        }
         if let Some(bus_code) = &modify_req.bus_code {
             rbum_set_cate.bus_code = Set(bus_code.to_string());
         }
@@ -816,6 +829,88 @@ impl RbumSetCateServ {
             .sys_code;
         Ok(sys_code)
     }
+
+    #[async_recursion]
+    pub async fn move_set_cate(set_cate_id: &str, parent_set_cate_id: &str, funs: &TardisFunsInst, ctx: &TardisContext) -> TardisResult<()> {
+        let set_cate_detail = Self::get_rbum(
+            set_cate_id,
+            &RbumSetCateFilterReq {
+                basic: RbumBasicFilterReq {
+                    with_sub_own_paths: true,
+                    ..Default::default()
+                },
+                ..Default::default()
+            },
+            funs,
+            ctx,
+        )
+        .await?;
+
+        let result = Self::modify_rbum(
+            set_cate_id,
+            &mut RbumSetCateModifyReq {
+                bus_code: None,
+                name: None,
+                icon: None,
+                sort: None,
+                ext: None,
+                rbum_parent_cate_id: Some(parent_set_cate_id.to_string()),
+                scope_level: None,
+            },
+            funs,
+            ctx,
+        )
+        .await;
+        let new_sys_code = Self::get_rbum(
+            set_cate_id,
+            &RbumSetCateFilterReq {
+                basic: RbumBasicFilterReq {
+                    with_sub_own_paths: true,
+                    ..Default::default()
+                },
+                ..Default::default()
+            },
+            funs,
+            ctx,
+        )
+        .await?.sys_code;
+        let set_item_ids = RbumSetItemServ::find_id_rbums(&RbumSetItemFilterReq {
+            sys_code_query_kind: Some(RbumSetCateLevelQueryKind::Current),
+            rel_rbum_set_cate_sys_codes: Some(vec![]),
+            ..Default::default()
+        }, None, None, funs, ctx).await?;
+        for set_item_id in set_item_ids {
+            RbumSetItemServ::modify_rbum(&set_item_id, &mut RbumSetItemModifyReq {
+                rel_rbum_set_cate_id: Some(new_sys_code.clone()),
+                sort: None,
+            }, funs, ctx).await?;
+        }
+
+        let child_set_cates = Self::find_rbums(
+            &RbumSetCateFilterReq {
+                basic: RbumBasicFilterReq {
+                    with_sub_own_paths: true,
+                    ..Default::default()
+                },
+                rel_rbum_set_id: Some(set_cate_detail.rel_rbum_set_id.clone()),
+                sys_codes: Some(vec![set_cate_detail.sys_code.clone()]),
+                sys_code_query_kind: Some(RbumSetCateLevelQueryKind::Sub),
+                sys_code_query_depth: Some(1),
+                cate_exts: None,
+                ..Default::default()
+            },
+            None,
+            None,
+            funs,
+            ctx,
+        )
+        .await?;
+        for child_set_cate in child_set_cates {
+            Self::move_set_cate(&child_set_cate.id, &set_cate_detail.id, funs, ctx).await?;
+        }
+
+        result
+    }
 }
 
 #[async_trait]
@@ -869,12 +964,19 @@ impl RbumCrudOperation<rbum_set_item::ActiveModel, RbumSetItemAddReq, RbumSetIte
         })
     }
 
-    async fn package_modify(id: &str, modify_req: &RbumSetItemModifyReq, _: &TardisFunsInst, _: &TardisContext) -> TardisResult<rbum_set_item::ActiveModel> {
-        Ok(rbum_set_item::ActiveModel {
+    async fn package_modify(id: &str, modify_req: &RbumSetItemModifyReq, funs: &TardisFunsInst, ctx: &TardisContext) -> TardisResult<rbum_set_item::ActiveModel> {
+        let mut rbum_set_item = rbum_set_item::ActiveModel {
             id: Set(id.to_string()),
-            sort: Set(modify_req.sort),
             ..Default::default()
-        })
+        };
+        if let Some(sort) = modify_req.sort {
+            rbum_set_item.sort = Set(sort);
+        }
+        if let Some(rel_rbum_set_cate_id) = &modify_req.rel_rbum_set_cate_id {
+            rbum_set_item.rel_rbum_set_cate_code = Set(RbumSetCateServ::get_sys_code(rel_rbum_set_cate_id.as_str(), funs, ctx).await?);
+        }
+
+        Ok(rbum_set_item)
     }
 
     async fn package_query(is_detail: bool, filter: &RbumSetItemFilterReq, funs: &TardisFunsInst, ctx: &TardisContext) -> TardisResult<SelectStatement> {

backend/basic/tests/test_rbum_set.rs

@@ -322,6 +322,7 @@ async fn test_rbum_set_cate(context: &TardisContext) -> TardisResult<()> {
             icon: None,
             sort: None,
             ext: None,
+            rbum_parent_cate_id: None,
             scope_level: None,
         },
         &funs,
@@ -1088,7 +1089,7 @@ async fn test_rbum_set_item(context: &TardisContext) -> TardisResult<()> {
     assert_eq!(rbum.rel_rbum_item_name, "用户1");
 
     info!("【test_rbum_set_item】 : Test Modify : RbumSetItemServ::modify_rbum");
-    RbumSetItemServ::modify_rbum(&id, &mut RbumSetItemModifyReq { sort: 10 }, &funs, context).await?;
+    RbumSetItemServ::modify_rbum(&id, &mut RbumSetItemModifyReq { sort: Some(10), rel_rbum_set_cate_id: None, }, &funs, context).await?;
 
     info!("【test_rbum_set_item】 : Test Find : RbumSetItemServ::paginate_rbums");
     let rbums = RbumSetItemServ::paginate_rbums(

backend/supports/iam/src/basic/serv/iam_set_serv.rs

@@ -215,6 +215,7 @@ impl IamSetServ {
                 icon: modify_req.icon.clone(),
                 sort: modify_req.sort,
                 ext: modify_req.ext.clone(),
+                rbum_parent_cate_id: None,
                 scope_level: modify_req.scope_level.clone(),
             },
             funs,
@@ -293,6 +294,10 @@ impl IamSetServ {
         result
     }
 
+    pub async fn move_set_cate(set_cate_id: &str, parent_set_cate_id: &str, funs: &TardisFunsInst, ctx: &TardisContext) -> TardisResult<()> {
+        RbumSetCateServ::move_set_cate(set_cate_id, parent_set_cate_id, funs, ctx).await
+    }
+
     pub async fn delete_set_cate(set_cate_id: &str, funs: &TardisFunsInst, ctx: &TardisContext) -> TardisResult<u64> {
         let set_cate_item = RbumSetCateServ::get_rbum(
             set_cate_id,

backend/supports/iam/src/console_system/api/iam_cs_res_api.rs

@@ -341,4 +341,17 @@ impl IamCsResApi {
         ctx.0.execute_task().await?;
         TardisResp::ok(Void {})
     }
+
+    /// Modify Parent Cate Id By Res Cate Id
+    /// 
+    #[oai(path = "/cate/:id/parent/:parent_cate_id", method = "put")]
+    async fn move_set_cate(&self, id: Path<String>, parent_cate_id: Path<String>, ctx: TardisContextExtractor, request: &Request) -> TardisApiResult<Void> {
+        try_set_real_ip_from_req_to_ctx(request, &ctx.0).await?;
+        let mut funs = iam_constants::get_tardis_inst();
+        funs.begin().await?;
+        IamSetServ::move_set_cate(&id.0, &parent_cate_id.0, &funs, &ctx.0).await?;
+        funs.commit().await?;
+        ctx.0.execute_task().await?;
+        TardisResp::ok(Void {})
+    }
 }

backend/supports/iam/tests/test_cc_set.rs

@@ -182,8 +182,8 @@ async fn test_single_level(context: &TardisContext, another_context: &TardisCont
     .is_err());
 
     info!("【test_ca_set】 : test_single_level : Modify Set Item By Id");
-    assert!(IamSetServ::modify_set_item(&item_id1, &mut RbumSetItemModifyReq { sort: 10 }, &funs, another_context).await.is_err());
-    IamSetServ::modify_set_item(&item_id1, &mut RbumSetItemModifyReq { sort: 10 }, &funs, context).await?;
+    assert!(IamSetServ::modify_set_item(&item_id1, &mut RbumSetItemModifyReq { sort: Some(10), rel_rbum_set_cate_id: None, }, &funs, another_context).await.is_err());
+    IamSetServ::modify_set_item(&item_id1, &mut RbumSetItemModifyReq { sort: Some(10), rel_rbum_set_cate_id: None, }, &funs, context).await?;
 
     info!("【test_ca_set】 : test_single_level : Find Set Item");
     let items = IamSetServ::find_set_items(None, Some(set_cate_id1.clone()), None, None, false, None, &funs, context).await?;