机构、部门、员工进行级联树关系整理

业务背景需要将机构和部门员工串联起来，然后搜索机构或者员工，如果有对应机构则将机构及部门员工展示查出来

第一步查询机构数据（查询机构和部门）：

public ResultDto<DynamicStaffsOrgDTO> getDynamicStaffs(UserInfo userInfo, String content) {
    log.info("ManagementUserServiceImpl.getDynamicStaffs查询机构部门员工:{}",content);
    DynamicStaffsOrgDTO dynamicStaffsOrgDTO=new DynamicStaffsOrgDTO();
    //先查询是否机构再查询员工
    AtomicBoolean queryStaffSwatch = new AtomicBoolean(true);
    //查询机构
    List<ManagementDynamicOrgDTO> orgs=queryOrgs(userInfo,content,queryStaffSwatch);
    //查询部门
    if(queryStaffSwatch.get()){
        //查询机构时已将机构和部门级联关系组装好，跳过此步骤
        queryDepts(userInfo,orgs);
    }
    //查询人员
    queryStaffs(userInfo,orgs,content,queryStaffSwatch);
    removeNullChildren(orgs);
    dynamicStaffsOrgDTO.setOrgs(orgs);
    return ResultDto.success(dynamicStaffsOrgDTO);
}

private List<ManagementDynamicOrgDTO> queryOrgs(UserInfo userInfo, String content, AtomicBoolean queryStaffSwatch) {
    List<ManagementDynamicOrgDTO> orgs=new ArrayList<ManagementDynamicOrgDTO>();
    log.info("查询所指定租户:{}下所有机构",userInfo.getTenantId());
    String participantToken =getParticipantToken(userInfo);
    JSONObject param=new JSONObject();
    param.put("funcType","unit");
    param.put("noNeedManager",true);
    param.put("status",0);
    param.put("topOrgId","");
    param.put("content",content);
    Request request = assembleRequest(param,participantToken,queryOrgsUrl);
    OkHttpClientConfig okHttpClientConfig = new OkHttpClientConfig();
    String strResponseBody = okHttpClientConfig.postOkHttpClientHeader(request);
    log.info("查询所有结构列表获得响应内容:{}",strResponseBody);
    ManagementOrgBaseResponseDTO responseDto= JSONObject.parseObject(strResponseBody,ManagementOrgBaseResponseDTO.class);
    if("200".equals(responseDto.getCode())){
        JSONArray oriResult= (JSONArray) responseDto.getData();
        orgs=oriResult.toJavaList(ManagementDynamicOrgDTO.class).stream().map(item->new ManagementDynamicOrgDTO(item.getId(),item.getName(),item.getParentId(),item.getNamePath(),item.getIdPath(),item.getTopOrgId(),1))
                .collect(Collectors.toList());
    }
    //说明查询的机构不存在，则返回所有机构继续查询人员名称
    if(CollectionUtils.isEmpty(orgs)){
        log.info("查询机构名称不存在匹配数据,则查询所有机构数据");
        List<ManagementOrgDTO> data = getOrgs(userInfo).getData();
        orgs=data.stream().map(org->new ManagementDynamicOrgDTO(org.getId(),org.getName(),"",1)).collect(Collectors.toList());
    }else{
        //非空说明用户查询的就是机构，则不在查询人员
        queryStaffSwatch.set(false);
        //查询出的机构数据不是级联结构，需要对机构数据进行重新组装成级联结构 而且不需要再查询部门数据
        orgs=assembleOrgsAndDepts(orgs);
    }
    return orgs;
}

private List<ManagementDynamicOrgDTO> assembleOrgsAndDepts(List<ManagementDynamicOrgDTO> orgList) {
    Map<String, ManagementDynamicOrgDTO> map = new HashMap<>();
    List<ManagementDynamicOrgDTO> roots = new ArrayList<>();
    for (ManagementDynamicOrgDTO org : orgList) {
        String idPath=org.getIdPath();
        String namePath=org.getNamePath();
        String parentId=org.getParentId();
        while (idPath.contains("/")) {
            int lastIdSlashIndex = idPath.lastIndexOf('/');
            int lastNameSlashIndex = namePath.lastIndexOf('/');
            String partIdAfterLastSlash = idPath.substring(lastIdSlashIndex + 1);
            String partNameAfterLastSlash =namePath.substring((lastNameSlashIndex + 1));
            // 更新 idPath 为去掉最后一个部分的字符串
            idPath = idPath.substring(0, lastIdSlashIndex);
            namePath=namePath.substring(0,lastNameSlashIndex);
            ManagementDynamicOrgDTO dept=new ManagementDynamicOrgDTO();
            dept.setId(partIdAfterLastSlash);
            dept.setName(partNameAfterLastSlash);
            dept.setParentId(parentId);
            dept.setType(2);
            //寻找父节点的ID
            parentId=getParentId(idPath);
            map.put(partIdAfterLastSlash, dept);
        }
        //最后根节点也要存入map
        ManagementDynamicOrgDTO dept=new ManagementDynamicOrgDTO();
        dept.setId(idPath);
        dept.setName(namePath);
        dept.setParentId("");
        dept.setType(1);
        map.put(idPath, dept);
    }
    Iterator<String> deptsKey = map.keySet().iterator();
    while (deptsKey.hasNext()){
        String deptId = deptsKey.next();
        ManagementDynamicOrgDTO managementDynamicOrgDTO = map.get(deptId);
        String parentId = managementDynamicOrgDTO.getParentId();
        //此dept是parentId的那个child
        if(StringUtils.isNotBlank(parentId)){
            ManagementDynamicOrgDTO parentDept = map.get(parentId);
            parentDept=selfCycle(managementDynamicOrgDTO,parentDept,map);
            if(StringUtils.isBlank(parentDept.getParentId())){
                roots.add(parentDept);
            }
            //map.put(parentId,parentDept);
        }
        //roots.add(managementDynamicOrgDTO);
    }
    return roots;
}

private ManagementDynamicOrgDTO selfCycle(ManagementDynamicOrgDTO currentDept,ManagementDynamicOrgDTO parentDept, Map<String, ManagementDynamicOrgDTO> map) {
    List<ManagementDynamicOrgDTO> children = parentDept.getChildren();
    if(CollectionUtils.isEmpty(children)){
        children=new ArrayList<>();
    }
    if(!children.contains(currentDept)){
        children.add(currentDept);
        parentDept.setChildren(children);
    }
    if(StringUtils.isNotBlank(parentDept.getParentId())){
        selfCycle(parentDept,map.get(parentDept.getParentId()),map);
    }
    return parentDept;
}

private String getParentId(String idPath) {
    String[] idArr = idPath.split("/");
    if(idArr.length==1){
        return "";
    }
    return idArr[idArr.length-2];
}

第二步 ：如果发现查询的机构部门列表是空，则表示搜索的是员工：查询机构下部门列表

private void queryDepts(UserInfo userInfo, List<ManagementDynamicOrgDTO> orgs) {
    orgs.stream().parallel().forEach(org->{
        List<ManagementDeptDTO> depts = getDepts(userInfo, org.getId()).getData();
        if(!CollectionUtils.isEmpty(depts)){
            List<ManagementDynamicOrgDTO> childDepts=depts.stream().map(item->new ManagementDynamicOrgDTO(item.getId(),item.getName(),item.getParentId(),2))
                    .collect(Collectors.toList());
            queryDepts(userInfo,childDepts);
            org.setChildren(childDepts);
        }
    });
}

然后第三步：查询部门下员工列表

private void queryStaffs(UserInfo userInfo, List<ManagementDynamicOrgDTO> orgs, String content, AtomicBoolean queryStaffSwatch) {
    final String[] tempContent = {content};
    if(!queryStaffSwatch.get()){
        //查询机构 不需要查询员工了
        tempContent[0] ="";
    }
    orgs.stream().parallel().forEach(org->{
        List<ManagementDynamicOrgDTO> childrenDept = org.getChildren();
        //查询该组织是否有直接员工
        ManagementStaffRequestDTO directStaffRequestDTO=new ManagementStaffRequestDTO();
        directStaffRequestDTO.setRealName(tempContent[0]);
        directStaffRequestDTO.setDeptId(org.getId());
        List<ManagementStaffsDTO> directStaffs = getStaffs(userInfo, directStaffRequestDTO).getData();
        List<ManagementDynamicOrgDTO> directStaffResult=directStaffs.stream().map(staff->new ManagementDynamicOrgDTO(staff.getId(),staff.getName(),staff.getParentId(),3)).collect(Collectors.toList());
        if(CollectionUtils.isEmpty(childrenDept)){
            //没有部门 查询是否有直接员工 如果直接员工也没有则删除该组织
            return;
        }
        childrenDept.stream().forEach(dept->{
            ManagementStaffRequestDTO staffRequestDTO=new ManagementStaffRequestDTO();
            List<ManagementDynamicOrgDTO> children = dept.getChildren();
            if(!CollectionUtils.isEmpty(children)){
                //部门下面还有部门
                queryStaffs(userInfo,children,content,queryStaffSwatch);
                dept.setChildren(children);
            }
            staffRequestDTO.setRealName(tempContent[0]);
            staffRequestDTO.setDeptId(dept.getId());
            List<ManagementStaffsDTO> staffs = getStaffs(userInfo, staffRequestDTO).getData();
            List<ManagementDynamicOrgDTO> result=staffs.stream().map(staff->new ManagementDynamicOrgDTO(staff.getId(),staff.getName(),staff.getParentId(),3)).collect(Collectors.toList());
            if(!CollectionUtils.isEmpty(children)){
                children.addAll(result);
            }else{
                dept.setChildren(result);
            }
        });
        childrenDept.addAll(directStaffResult);
        org.setChildren(childrenDept);
    });
}

最后一步：发现如果部门下员工空，则将部门移除掉

private void removeNullChildren(List<ManagementDynamicOrgDTO> orgs) {
    Iterator<ManagementDynamicOrgDTO> iterator = orgs.iterator();
    while(iterator.hasNext()){
        ManagementDynamicOrgDTO org = iterator.next();
        List<ManagementDynamicOrgDTO> children = org.getChildren();
        if(!CollectionUtils.isEmpty(children)){
            removeNullChildren(children);
            if(children.size()==0){
                iterator.remove();
            }
        }else if(Objects.nonNull(children) && children.size()==0){
            iterator.remove();
        }
    }

}