perf: 优化部门管理模块service层及异常处理

ruoyi-fastapi-backend/config/constant.py

@@ -6,6 +6,8 @@ class CommonConstant:
     HTTPS: https请求
     YES: 是否为系统默认（是）
     NO: 是否为系统默认（否）
+    DEPT_NORMAL: 部门正常状态
+    DEPT_DISABLE: 部门停用状态
     UNIQUE: 校验是否唯一的返回标识（是）
     NOT_UNIQUE: 校验是否唯一的返回标识（否）
     """
@@ -14,6 +16,8 @@ class CommonConstant:
     HTTPS = 'https://'
     YES = 'Y'
     NO = 'N'
+    DEPT_NORMAL = '0'
+    DEPT_DISABLE = '1'
     UNIQUE = True
     NOT_UNIQUE = False
 

ruoyi-fastapi-backend/module_admin/controller/dept_controller.py

@@ -17,92 +17,70 @@ deptController = APIRouter(prefix='/system/dept', dependencies=[Depends(LoginSer
 
 @deptController.get("/list/exclude/{dept_id}", response_model=List[DeptModel], dependencies=[Depends(CheckUserInterfaceAuth('system:dept:list'))])
 async def get_system_dept_tree_for_edit_option(request: Request, dept_id: int, query_db: AsyncSession = Depends(get_db), data_scope_sql: str = Depends(GetDataScope('SysDept'))):
-    try:
+    dept_query = DeptModel(deptId=dept_id)
-        dept_query = DeptModel(deptId=dept_id)
+    dept_query_result = await DeptService.get_dept_for_edit_option_services(query_db, dept_query, data_scope_sql)
-        dept_query_result = await DeptService.get_dept_for_edit_option_services(query_db, dept_query, data_scope_sql)
+    logger.info('获取成功')
-        logger.info('获取成功')
+
-        return ResponseUtil.success(data=dept_query_result)
+    return ResponseUtil.success(data=dept_query_result)
-    except Exception as e:
-        logger.exception(e)
-        return ResponseUtil.error(msg=str(e))
 
 
 @deptController.get("/list", response_model=List[DeptModel], dependencies=[Depends(CheckUserInterfaceAuth('system:dept:list'))])
 async def get_system_dept_list(request: Request, dept_query: DeptQueryModel = Depends(DeptQueryModel.as_query), query_db: AsyncSession = Depends(get_db), data_scope_sql: str = Depends(GetDataScope('SysDept'))):
-    try:
+    dept_query_result = await DeptService.get_dept_list_services(query_db, dept_query, data_scope_sql)
-        dept_query_result = await DeptService.get_dept_list_services(query_db, dept_query, data_scope_sql)
+    logger.info('获取成功')
-        logger.info('获取成功')
+
-        return ResponseUtil.success(data=dept_query_result)
+    return ResponseUtil.success(data=dept_query_result)
-    except Exception as e:
-        logger.exception(e)
-        return ResponseUtil.error(msg=str(e))
 
 
 @deptController.post("", dependencies=[Depends(CheckUserInterfaceAuth('system:dept:add'))])
 @ValidateFields(validate_model='add_dept')
 @log_decorator(title='部门管理', business_type=BusinessType.INSERT)
 async def add_system_dept(request: Request, add_dept: DeptModel, query_db: AsyncSession = Depends(get_db), current_user: CurrentUserModel = Depends(LoginService.get_current_user)):
-    try:
+    add_dept.create_by = current_user.user.user_name
-        add_dept.create_by = current_user.user.user_name
+    add_dept.create_time = datetime.now()
-        add_dept.create_time = datetime.now()
+    add_dept.update_by = current_user.user.user_name
-        add_dept.update_by = current_user.user.user_name
+    add_dept.update_time = datetime.now()
-        add_dept.update_time = datetime.now()
+    add_dept_result = await DeptService.add_dept_services(query_db, add_dept)
-        add_dept_result = await DeptService.add_dept_services(query_db, add_dept)
+    logger.info(add_dept_result.message)
-        if add_dept_result.is_success:
+
-            logger.info(add_dept_result.message)
+    return ResponseUtil.success(data=add_dept_result)
-            return ResponseUtil.success(data=add_dept_result)
-        else:
-            logger.warning(add_dept_result.message)
-            return ResponseUtil.failure(msg=add_dept_result.message)
-    except Exception as e:
-        logger.exception(e)
-        return ResponseUtil.error(msg=str(e))
 
 
 @deptController.put("", dependencies=[Depends(CheckUserInterfaceAuth('system:dept:edit'))])
 @ValidateFields(validate_model='edit_dept')
 @log_decorator(title='部门管理', business_type=BusinessType.UPDATE)
-async def edit_system_dept(request: Request, edit_dept: DeptModel, query_db: AsyncSession = Depends(get_db), current_user: CurrentUserModel = Depends(LoginService.get_current_user)):
+async def edit_system_dept(request: Request, edit_dept: DeptModel, query_db: AsyncSession = Depends(get_db), current_user: CurrentUserModel = Depends(LoginService.get_current_user), data_scope_sql: str = Depends(GetDataScope('SysDept'))):
-    try:
+    if not current_user.user.admin:
-        edit_dept.update_by = current_user.user.user_name
+        await DeptService.check_dept_data_scope_services(query_db, edit_dept.dept_id, data_scope_sql)
-        edit_dept.update_time = datetime.now()
+    edit_dept.update_by = current_user.user.user_name
-        edit_dept_result = await DeptService.edit_dept_services(query_db, edit_dept)
+    edit_dept.update_time = datetime.now()
-        if edit_dept_result.is_success:
+    edit_dept_result = await DeptService.edit_dept_services(query_db, edit_dept)
-            logger.info(edit_dept_result.message)
+    logger.info(edit_dept_result.message)
-            return ResponseUtil.success(msg=edit_dept_result.message)
+
-        else:
+    return ResponseUtil.success(msg=edit_dept_result.message)
-            logger.warning(edit_dept_result.message)
-            return ResponseUtil.failure(msg=edit_dept_result.message)
-    except Exception as e:
-        logger.exception(e)
-        return ResponseUtil.error(msg=str(e))
 
 
 @deptController.delete("/{dept_ids}", dependencies=[Depends(CheckUserInterfaceAuth('system:dept:remove'))])
 @log_decorator(title='部门管理', business_type=BusinessType.DELETE)
-async def delete_system_dept(request: Request, dept_ids: str, query_db: AsyncSession = Depends(get_db), current_user: CurrentUserModel = Depends(LoginService.get_current_user)):
+async def delete_system_dept(request: Request, dept_ids: str, query_db: AsyncSession = Depends(get_db), current_user: CurrentUserModel = Depends(LoginService.get_current_user), data_scope_sql: str = Depends(GetDataScope('SysDept'))):
-    try:
+    dept_id_list = dept_ids.split(',')
-        delete_dept = DeleteDeptModel(deptIds=dept_ids)
+    for dept_id in dept_id_list:
-        delete_dept.update_by = current_user.user.user_name
+        if not current_user.user.admin:
-        delete_dept.update_time = datetime.now()
+            await DeptService.check_dept_data_scope_services(query_db, int(dept_id), data_scope_sql)
-        delete_dept_result = await DeptService.delete_dept_services(query_db, delete_dept)
+    delete_dept = DeleteDeptModel(deptIds=dept_ids)
-        if delete_dept_result.is_success:
+    delete_dept.update_by = current_user.user.user_name
-            logger.info(delete_dept_result.message)
+    delete_dept.update_time = datetime.now()
-            return ResponseUtil.success(msg=delete_dept_result.message)
+    delete_dept_result = await DeptService.delete_dept_services(query_db, delete_dept)
-        else:
+    logger.info(delete_dept_result.message)
-            logger.warning(delete_dept_result.message)
+
-            return ResponseUtil.failure(msg=delete_dept_result.message)
+    return ResponseUtil.success(msg=delete_dept_result.message)
-    except Exception as e:
-        logger.exception(e)
-        return ResponseUtil.error(msg=str(e))
 
 
 @deptController.get("/{dept_id}", response_model=DeptModel, dependencies=[Depends(CheckUserInterfaceAuth('system:dept:query'))])
-async def query_detail_system_dept(request: Request, dept_id: int, query_db: AsyncSession = Depends(get_db)):
+async def query_detail_system_dept(request: Request, dept_id: int, query_db: AsyncSession = Depends(get_db), current_user: CurrentUserModel = Depends(LoginService.get_current_user), data_scope_sql: str = Depends(GetDataScope('SysDept'))):
-    try:
+    if not current_user.user.admin:
-        detail_dept_result = await DeptService.dept_detail_services(query_db, dept_id)
+        await DeptService.check_dept_data_scope_services(query_db, dept_id, data_scope_sql)
-        logger.info(f'获取dept_id为{dept_id}的信息成功')
+    detail_dept_result = await DeptService.dept_detail_services(query_db, dept_id)
-        return ResponseUtil.success(data=detail_dept_result)
+    logger.info(f'获取dept_id为{dept_id}的信息成功')
-    except Exception as e:
+
-        logger.exception(e)
+    return ResponseUtil.success(data=detail_dept_result)
-        return ResponseUtil.error(msg=str(e))

ruoyi-fastapi-backend/module_admin/dao/dept_dao.py

@@ -1,9 +1,10 @@
-from sqlalchemy import select, update, delete, or_, func
+from sqlalchemy import select, update, delete, or_, func, bindparam
 from sqlalchemy.ext.asyncio import AsyncSession
+from sqlalchemy.util import immutabledict
 from module_admin.entity.do.dept_do import SysDept
+from module_admin.entity.do.user_do import SysUser
 from module_admin.entity.do.role_do import SysRoleDept
 from module_admin.entity.vo.dept_vo import *
-from utils.time_format_util import list_format_datetime
 
 
 class DeptDao:
@@ -21,25 +22,7 @@ class DeptDao:
         """
         dept_info = (await db.execute(
             select(SysDept)
-                .where(SysDept.dept_id == dept_id,
+                .where(SysDept.dept_id == dept_id)
-                       SysDept.status == '0',
-                       SysDept.del_flag == '0')
-        )).scalars().first()
-
-        return dept_info
-
-    @classmethod
-    async def get_dept_by_id_for_list(cls, db: AsyncSession, dept_id: int):
-        """
-        用于获取部门列表的工具方法
-        :param db: orm对象
-        :param dept_id: 部门id
-        :return: 部门id对应的信息对象
-        """
-        dept_info = (await db.execute(
-            select(SysDept)
-                .where(SysDept.dept_id == dept_id,
-                       SysDept.del_flag == '0')
         )).scalars().first()
 
         return dept_info
@@ -98,7 +81,7 @@ class DeptDao:
         return dept_result
 
     @classmethod
-    async def get_children_dept(cls, db: AsyncSession, dept_id: int):
+    async def get_children_dept_dao(cls, db: AsyncSession, dept_id: int):
         """
         根据部门id查询当前部门的子部门列表信息
         :param db: orm对象
@@ -107,25 +90,10 @@ class DeptDao:
         """
         dept_result = (await db.execute(
             select(SysDept)
-                .where(SysDept.parent_id == dept_id,
+                .where(func.find_in_set(dept_id, SysDept.ancestors))
-                       SysDept.del_flag == '0')
         )).scalars().all()
 
-        return list_format_datetime(dept_result)
+        return dept_result
-
-    @classmethod
-    async def get_dept_all_ancestors(cls, db: AsyncSession):
-        """
-        获取所有部门的ancestors信息
-        :param db: orm对象
-        :return: ancestors信息列表
-        """
-        ancestors = (await db.execute(
-            select(SysDept.ancestors)
-                .where(SysDept.del_flag == '0')
-        )).scalars().all()
-
-        return ancestors
 
     @classmethod
     async def get_dept_list_for_tree(cls, db: AsyncSession, dept_info: DeptModel, data_scope_sql: str):
@@ -196,6 +164,43 @@ class DeptDao:
             [dept]
         )
 
+    @classmethod
+    async def update_dept_children_dao(cls, db: AsyncSession, update_dept: List):
+        """
+        更新子部门信息
+        :param db: orm对象
+        :param update_dept: 需要更新的部门列表
+        :return:
+        """
+        await db.execute(
+            update(SysDept)
+                .where(SysDept.dept_id == bindparam('dept_id'))
+                .values(
+                {
+                    'dept_id': bindparam('dept_id'),
+                    'ancestors': bindparam('ancestors'),
+                }
+            ),
+            update_dept,
+            execution_options=immutabledict(
+                {"synchronize_session": None}
+            )
+        )
+
+    @classmethod
+    async def update_dept_status_normal_dao(cls, db: AsyncSession, dept_id_list: List):
+        """
+        批量更新部门状态为正常
+        :param db: orm对象
+        :param dept_id_list: 部门id列表
+        :return:
+        """
+        await db.execute(
+            update(SysDept)
+                .where(SysDept.dept_id.in_(dept_id_list))
+                .values(status='0')
+        )
+
     @classmethod
     async def delete_dept_dao(cls, db: AsyncSession, dept: DeptModel):
         """
@@ -209,3 +214,57 @@ class DeptDao:
                 .where(SysDept.dept_id == dept.dept_id)
                 .values(del_flag='2', update_by=dept.update_by, update_time=dept.update_time)
         )
+
+    @classmethod
+    async def count_normal_children_dept_dao(cls, db: AsyncSession, dept_id: int):
+        """
+        根据部门id查询查询所有子部门（正常状态）的数量
+        :param db: orm对象
+        :param dept_id: 部门id
+        :return: 所有子部门（正常状态）的数量
+        """
+        normal_children_dept_count = (await db.execute(
+            select(func.count('*'))
+                .select_from(SysDept)
+                .where(
+                SysDept.status == '0',
+                SysDept.del_flag == '0',
+                func.find_in_set(dept_id, SysDept.ancestors)
+            )
+        )).scalar()
+
+        return normal_children_dept_count
+
+    @classmethod
+    async def count_children_dept_dao(cls, db: AsyncSession, dept_id: int):
+        """
+        根据部门id查询查询所有子部门（所有状态）的数量
+        :param db: orm对象
+        :param dept_id: 部门id
+        :return: 所有子部门（所有状态）的数量
+        """
+        children_dept_count = (await db.execute(
+            select(func.count('*'))
+                .select_from(SysDept)
+                .where(SysDept.del_flag == '0',
+                       SysDept.parent_id == dept_id)
+                .limit(1)
+        )).scalar()
+
+        return children_dept_count
+
+    @classmethod
+    async def count_dept_user_dao(cls, db: AsyncSession, dept_id: int):
+        """
+        根据部门id查询查询部门下的用户数量
+        :param db: orm对象
+        :param dept_id: 部门id
+        :return: 部门下的用户数量
+        """
+        dept_user_count = (await db.execute(
+            select(func.count('*'))
+                .select_from(SysUser)
+                .where(SysUser.dept_id == dept_id, SysUser.del_flag == '0')
+        )).scalar()
+
+        return dept_user_count

ruoyi-fastapi-backend/module_admin/service/dept_service.py

@@ -1,5 +1,7 @@
 from module_admin.dao.dept_dao import *
 from module_admin.entity.vo.common_vo import CrudResponseModel
+from config.constant import CommonConstant
+from exceptions.exception import ServiceException
 from utils.common_util import CamelCaseUtil
 
 
@@ -49,6 +51,35 @@ class DeptService:
 
         return CamelCaseUtil.transform_result(dept_list_result)
 
+    @classmethod
+    async def check_dept_data_scope_services(cls, query_db: AsyncSession, dept_id: int, data_scope_sql: str):
+        """
+        校验部门是否有数据权限service
+        :param query_db: orm对象
+        :param dept_id: 部门id
+        :param data_scope_sql: 数据权限对应的查询sql语句
+        :return: 校验结果
+        """
+        depts = await DeptDao.get_dept_list(query_db, DeptModel(deptId=dept_id), data_scope_sql)
+        if depts:
+            return CrudResponseModel(is_success=True, message='校验通过')
+        else:
+            raise ServiceException(message='没有权限访问部门数据')
+
+    @classmethod
+    async def check_dept_name_unique_services(cls, query_db: AsyncSession, page_object: DeptModel):
+        """
+        校验部门名称是否唯一service
+        :param query_db: orm对象
+        :param page_object: 部门对象
+        :return: 校验结果
+        """
+        dept_id = -1 if page_object.dept_id is None else page_object.dept_id
+        dept = await DeptDao.get_dept_detail_by_info(query_db, DeptModel(deptName=page_object.dept_name, parentId=page_object.parent_id))
+        if dept and dept.dept_id != dept_id:
+            return CommonConstant.NOT_UNIQUE
+        return CommonConstant.UNIQUE
+
     @classmethod
     async def add_dept_services(cls, query_db: AsyncSession, page_object: DeptModel):
         """
@@ -57,25 +88,19 @@ class DeptService:
         :param page_object: 新增部门对象
         :return: 新增部门校验结果
         """
+        if not await cls.check_dept_name_unique_services(query_db, page_object):
+            raise ServiceException(message=f'新增部门{page_object.dept_name}失败，部门名称已存在')
         parent_info = await DeptDao.get_dept_by_id(query_db, page_object.parent_id)
-        if parent_info:
+        if parent_info.status != CommonConstant.DEPT_NORMAL:
-            page_object.ancestors = f'{parent_info.ancestors},{page_object.parent_id}'
+            raise ServiceException(message=f'部门{parent_info.dept_name}停用，不允许新增')
-        else:
+        page_object.ancestors = f'{parent_info.ancestors},{page_object.parent_id}'
-            page_object.ancestors = '0'
+        try:
-        dept = await DeptDao.get_dept_detail_by_info(query_db, DeptModel(parentId=page_object.parent_id,
+            await DeptDao.add_dept_dao(query_db, page_object)
-                                                                         deptName=page_object.dept_name))
+            await query_db.commit()
-        if dept:
+            return CrudResponseModel(is_success=True, message='新增成功')
-            result = dict(is_success=False, message='同一部门下不允许存在同名的部门')
+        except Exception as e:
-        else:
+            await query_db.rollback()
-            try:
+            raise e
-                await DeptDao.add_dept_dao(query_db, page_object)
-                await query_db.commit()
-                result = dict(is_success=True, message='新增成功')
-            except Exception as e:
-                await query_db.rollback()
-                raise e
-
-        return CrudResponseModel(**result)
 
     @classmethod
     async def edit_dept_services(cls, query_db: AsyncSession, page_object: DeptModel):
@@ -85,37 +110,29 @@ class DeptService:
         :param page_object: 编辑部门对象
         :return: 编辑部门校验结果
         """
-        parent_info = await DeptDao.get_dept_by_id(query_db, page_object.parent_id)
+        if not await cls.check_dept_name_unique_services(query_db, page_object):
-        if parent_info:
+            raise ServiceException(message=f'修改部门{page_object.dept_name}失败，部门名称已存在')
-            page_object.ancestors = f'{parent_info.ancestors},{page_object.parent_id}'
+        elif page_object.dept_id == page_object.parent_id:
-        else:
+            raise ServiceException(message=f'修改部门{page_object.dept_name}失败，上级部门不能是自己')
-            page_object.ancestors = '0'
+        elif page_object.status == CommonConstant.DEPT_DISABLE and (await DeptDao.count_normal_children_dept_dao(query_db, page_object.dept_id)) > 0:
-        edit_dept = page_object.model_dump(exclude_unset=True)
+            raise ServiceException(message=f'修改部门{page_object.dept_name}失败，该部门包含未停用的子部门')
-        dept_info = await cls.dept_detail_services(query_db, edit_dept.get('dept_id'))
+        new_parent_dept = await DeptDao.get_dept_by_id(query_db, page_object.parent_id)
-        if dept_info:
+        old_dept = await DeptDao.get_dept_by_id(query_db, page_object.dept_id)
-            if dept_info.parent_id != page_object.parent_id or dept_info.dept_name != page_object.dept_name:
+        try:
-                dept = await DeptDao.get_dept_detail_by_info(query_db, DeptModel(parentId=page_object.parent_id,
+            if new_parent_dept and old_dept:
-                                                                                 deptName=page_object.dept_name))
+                new_ancestors = f'{new_parent_dept.ancestors},{new_parent_dept.dept_id}'
-                if dept:
+                old_ancestors = old_dept.ancestors
-                    result = dict(is_success=False, message='同一部门下不允许存在同名的部门')
+                page_object.ancestors = new_ancestors
-                    return CrudResponseModel(**result)
+                await cls.update_dept_children(query_db, page_object.dept_id, new_ancestors, old_ancestors)
-            try:
+            edit_dept = page_object.model_dump(exclude_unset=True)
-                await DeptDao.edit_dept_dao(query_db, edit_dept)
+            await DeptDao.edit_dept_dao(query_db, edit_dept)
-                await cls.update_children_info(query_db, DeptModel(deptId=page_object.dept_id,
+            if page_object.status == CommonConstant.DEPT_NORMAL and page_object.ancestors and page_object.ancestors != 0:
-                                                                   ancestors=page_object.ancestors,
+                await cls.update_parent_dept_status_normal(query_db, page_object)
-                                                                   updateBy=page_object.update_by,
+            await query_db.commit()
-                                                                   updateTime=page_object.update_time
+            return CrudResponseModel(is_success=True, message='更新成功')
-                                                                   )
+        except Exception as e:
-                                               )
+            await query_db.rollback()
-                await query_db.commit()
+            raise e
-                result = dict(is_success=True, message='更新成功')
-            except Exception as e:
-                await query_db.rollback()
-                raise e
-        else:
-            result = dict(is_success=False, message='部门不存在')
-
-        return CrudResponseModel(**result)
 
     @classmethod
     async def delete_dept_services(cls, query_db: AsyncSession, page_object: DeleteDeptModel):
@@ -127,24 +144,21 @@ class DeptService:
         """
         if page_object.dept_ids.split(','):
             dept_id_list = page_object.dept_ids.split(',')
-            ancestors = await DeptDao.get_dept_all_ancestors(query_db)
             try:
                 for dept_id in dept_id_list:
-                    for ancestor in ancestors:
+                    if (await DeptDao.count_children_dept_dao(query_db, int(dept_id))) > 0:
-                        if dept_id in ancestor[0]:
+                        raise ServiceException(message='存在下级部门,不允许删除')
-                            result = dict(is_success=False, message='该部门下有子部门，不允许删除')
+                    elif (await DeptDao.count_dept_user_dao(query_db, int(dept_id))) > 0:
-
+                        raise ServiceException(message='部门存在用户,不允许删除')
-                            return CrudResponseModel(**result)
 
                     await DeptDao.delete_dept_dao(query_db, DeptModel(deptId=dept_id))
                 await query_db.commit()
-                result = dict(is_success=True, message='删除成功')
+                return CrudResponseModel(is_success=True, message='删除成功')
             except Exception as e:
                 await query_db.rollback()
                 raise e
         else:
-            result = dict(is_success=False, message='传入部门id为空')
+            raise ServiceException(message='传入部门id为空')
-        return CrudResponseModel(**result)
 
     @classmethod
     async def dept_detail_services(cls, query_db: AsyncSession, dept_id: int):
@@ -155,7 +169,10 @@ class DeptService:
         :return: 部门id对应的信息
         """
         dept = await DeptDao.get_dept_detail_by_id(query_db, dept_id=dept_id)
-        result = DeptModel(**CamelCaseUtil.transform_result(dept))
+        if dept:
+            result = DeptModel(**CamelCaseUtil.transform_result(dept))
+        else:
+            result = DeptModel(**dict())
 
         return result
 
@@ -189,26 +206,44 @@ class DeptService:
         return container
 
     @classmethod
-    async def update_children_info(cls, query_db, page_object):
+    async def replace_first(cls, original_str: str, old_str: str, new_str: str):
         """
-        工具方法：递归更新子部门信息
+        工具方法：替换字符串
+        :param original_str: 需要替换的原始字符串
+        :param old_str: 用于匹配的字符串
+        :param new_str: 替换的字符串
+        :return: 替换后的字符串
+        """
+        if original_str.startswith(old_str):
+            return original_str.replace(old_str, new_str, 1)
+        else:
+            return original_str
+
+    @classmethod
+    async def update_parent_dept_status_normal(cls, query_db: AsyncSession, dept: DeptModel):
+        """
+        更新父部门状态为正常
         :param query_db: orm对象
-        :param page_object: 编辑部门对象
+        :param dept: 部门对象
         :return:
         """
-        children_info = await DeptDao.get_children_dept(query_db, page_object.dept_id)
+        dept_id_list = dept.ancestors.split(',')
-        if children_info:
+        await DeptDao.update_dept_status_normal_dao(query_db, dept_id_list)
-            for child in children_info:
+
-                child.ancestors = f'{page_object.ancestors},{page_object.dept_id}'
+    @classmethod
-                await DeptDao.edit_dept_dao(query_db,
+    async def update_dept_children(cls, query_db: AsyncSession, dept_id: int, new_ancestors: str, old_ancestors: str):
-                                            dict(dept_id=child.dept_id,
+        """
-                                                 ancestors=child.ancestors,
+        更新子部门信息
-                                                 update_by=page_object.update_by,
+        :param query_db: orm对象
-                                                 update_time=page_object.update_time
+        :param dept_id: 部门id
-                                                 )
+        :param new_ancestors: 新的祖先
-                                            )
+        :param old_ancestors: 旧的祖先
-                await cls.update_children_info(query_db, DeptModel(dept_id=child.dept_id,
+        :return:
-                                                                   ancestors=child.ancestors,
+        """
-                                                                   update_by=page_object.update_by,
+        children = await DeptDao.get_children_dept_dao(query_db, dept_id)
-                                                                   update_time=page_object.update_time
+        update_children = []
-                                                                   ))
+        for child in children:
+            child_ancestors = await cls.replace_first(child.ancestors, old_ancestors, new_ancestors)
+            update_children.append({'dept_id': child.dept_id, 'ancestors': child_ancestors})
+        if children:
+            await DeptDao.update_dept_children_dao(query_db, update_children)