查找当前组织的所有子孙组织

  查出除根结点外所有经过筛选条件的数据
遍历所有数据
如果当前节点的


@Override
    public List<Type> getTypeTree(TypeParamsDto typeParamsDto) {
        // 从二级节点数据查起
        QueryWrapper queryWrapper = QueryWrapper.create().select(
                        TYPE.ALL_COLUMNS).from(TYPE)
                .where(TYPE.PARENT_ID.ne("0"))
                .orderBy(TYPE.SORT.asc(), TYPE.CREATE_TIME.desc());
//        if (StringUtils.isNotBlank(typeParamsDto.getTypeName())) {
//            queryWrapper.and(TYPE.TYPE_NAME.like("%" + typeParamsDto.getTypeName() + "%"));
//        }
        if (typeParamsDto.getTypeProperty() != null) {
            queryWrapper.and(TYPE.TYPE_PROPERTY.eq(typeParamsDto.getTypeProperty()));
        }
        if (StringUtils.isNotBlank(typeParamsDto.getCreateTimeStart())) {
            queryWrapper.and(TYPE.CREATE_TIME.ge(typeParamsDto.getCreateTimeStart() + " 00:00:00"));
        }
        if (StringUtils.isNotBlank(typeParamsDto.getCreateTimeStart())) {
            queryWrapper.and(TYPE.CREATE_TIME.le(typeParamsDto.getCreateTimeEnd() + " 23:59:59"));
        }
        List<Type> rootList = new ArrayList<>();
        // 经过筛选条件的查询集合
        List<Type> typeList = typeMapper.selectListByQuery(queryWrapper);
       
        // 1、查出没有根节点的list
        // 2、list转成map，typeId为key
        // 3、循环构建树
        Map<String, Type> typeMap = typeList.stream()
                .collect(Collectors.toMap(Type::getTypeId, Function.identity()));
        // 去除根节点后，TypeMap里面不包含根节点数据
        // 如果不包含，那么二级节点的parentId在TypeMap中找不到，找不到的情况下为二级节点，就将二级节点上提一层
        // 以此类推，三级节点中的parentId是二级节点的TypeId，那么TypeMap中是必然会包含的
        // 全集
        List<Type> types = this.queryChain().from(TYPE).where(TYPE.PARENT_ID.ne("0")).list();
        Map<String, Type> typeHashMap =
                types.stream().collect(Collectors.toMap(Type::getTypeId, Function.identity()));
        for (Type type : typeList) {
            Type parentType = new Type();
            // 如果条件集typeMap中存在父类型ID对应的typeId对应的类型
            if (ObjectUtils.isNotEmpty(typeMap.get(type.getParentId()))) {
                // 将该类型的属性复制给parentType
                BeanUtils.copyProperties(typeMap.get(type.getParentId()), parentType);
            }
            // 如果全集typeHashMap中存在父类型ID对应的typeId对应的类型
            if (ObjectUtils.isNotEmpty(typeHashMap.get(type.getParentId()))) {
                // 对应的类型的属性复制给parentType
                BeanUtils.copyProperties(typeHashMap.get(type.getParentId()), parentType);
            }
            // 此处判断的在TypeMap中未能获取到当前数据的parentId，那么 == 二级节点
            // 如果我有上级，将我加入上级的children Type中；
            // 什么情况下把我加入根节点，1：我没有上级；或者   2：我有上级，但是我的上级不在筛选结果里；
            if (ValidationUtils.checkObjAllFieldsIsNull(parentType)
                    || typeMap.get(type.getParentId()) == null) {
                // 在此处加入根节点---
                // 我就是上级，把我加到rootList中，返回列表；并不把root返回；
                rootList.add(type);
            } else { // 如果我在上级前出现
                // 我有上级，并且我和上级都在筛选结果里，那么根据我的parentId，找到typeMap中的上级
                // 并且把我加入到typeMap该上级的children Type中
                // 如果上级在我之前出现 ，上级在rootList里----queryWrapper按时间降序查找，上级不可能在我之前遍历
                if (!ValidationUtils.checkObjAllFieldsIsNull(parentType.getChildren())) {
typeMap.get(type.getParentId()).getChildren().add(type);                
}
            }
        }
// 名称筛选
List<Type> resultList = new ArrayList<>();        
if(StringUtils.isNotBlank(typeParamsDto.getTypeName())){
resultList = searchByTypeName(typeParamsDto,rootList);        
}
if (StringUtils.isNotBlank(typeParamsDto.getTypeName())){
return resultList;        
}
return rootList;    
}

public List<Type> searchByTypeName(TypeParamsDto typeParamsDto, List<Type> rootList) {
        List<Type> resultList = new ArrayList<>();
    for (Type type : rootList) {
        depthFirstSearch(type, typeParamsDto, resultList);
    }
    return resultList;
}

private void depthFirstSearch(Type type, TypeParamsDto typeParamsDto, List<Type> resultList) {
    if (type.getTypeName().equals(typeParamsDto.getTypeName())) {
        resultList.add(type);
    } else{
        for (Type child : type.getChildren()) {
            depthFirstSearch(child, typeParamsDto, resultList);
        }
    }
}