PAS/src/main/java/cn/cslg/pas/service/business/TreeNodeService.java

package cn.cslg.pas.service.business;

import cn.cslg.pas.common.dto.CopyTreeNodeDTO;
import cn.cslg.pas.common.dto.business.QueryAllTreePathDTO;
import cn.cslg.pas.common.dto.business.QueryTreeNodeDTO;
import cn.cslg.pas.common.dto.business.TreeNodeDTO;
import cn.cslg.pas.common.dto.business.UpdateTreeNodeDTO;
import cn.cslg.pas.common.model.cronModel.*;
import cn.cslg.pas.common.model.request.GroupRequest;
import cn.cslg.pas.common.model.request.QueryRequest;
import cn.cslg.pas.common.utils.CacheUtils;
import cn.cslg.pas.common.utils.LoginUtils;
import cn.cslg.pas.common.vo.ReTreeNodeVO;
import cn.cslg.pas.common.vo.business.ProductVO;
import cn.cslg.pas.common.vo.business.TreeNodeVO;
import cn.cslg.pas.common.vo.business.TreePathVO;
import cn.cslg.pas.domain.business.AssoProjectTreeNode;
import cn.cslg.pas.domain.business.AssoTreeNodeFile;
import cn.cslg.pas.domain.business.TreeNode;
import cn.cslg.pas.exception.UnLoginException;
import cn.cslg.pas.exception.XiaoShiException;
import cn.cslg.pas.factorys.businessFactory.Business;
import cn.cslg.pas.mapper.TreeNodeMapper;
import cn.cslg.pas.service.business.es.EsProductPatentService;
import cn.cslg.pas.service.common.FileManagerService;
import cn.cslg.pas.service.permissions.PermissionService;
import cn.cslg.pas.service.query.FormatQueryService;
import com.alibaba.fastjson.JSONObject;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.lang3.StringUtils;
import org.springframework.beans.BeanUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.util.CollectionUtils;
import org.springframework.web.multipart.MultipartFile;

import java.io.IOException;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Comparator;
import java.util.List;
import java.util.stream.Collectors;

/**
 * 架构的Service层
 *
 * @Author xiexiang
 * @Date 2023/10/26
 */
@Service
@Slf4j
public class TreeNodeService extends ServiceImpl<TreeNodeMapper, TreeNode> implements Business {
    @Autowired
    private TreeNodeMapper treeNodeMapper;

    @Autowired
    private AssoTreeNodeFileService assoTreeNodeFileService;

    @Autowired
    private FileManagerService fileManagerService;

    @Autowired
    private CacheUtils cacheUtils;

    @Autowired
    private LoginUtils loginUtils;

    @Autowired
    private FormatQueryService formatQueryService;

    @Autowired
    private PermissionService permissionService;

    @Autowired
    private AssoProjectTreeNodeService assoProjectTreeNodeService;

    @Autowired
    private EsProductPatentService esProductPatentService;

    @Override
    public Object queryMessage(QueryRequest queryRequest) throws Exception {
        List<String> sqls = formatQueryService.reSqls(queryRequest, "treeNode");

        //根据sql查询节点信息
        List<TreeNodeVO> treeNodeVOS = this.getBaseMapper().getTreeNodes(sqls.get(0), sqls.get(1), sqls.get(2));
        //查询节点总数
        Long total = this.getBaseMapper().getTreeNodeCount(sqls.get(0));
        //装载节点信息
        if (treeNodeVOS.size() != 0) {
            this.loadTreeNode(treeNodeVOS);
            this.loadPath(treeNodeVOS);
        }
        Records records = new Records();
        records.setCurrent(queryRequest.getCurrent());
        records.setSize(queryRequest.getSize());
        records.setData(treeNodeVOS);
        records.setTotal(total);
        return records;
    }

    /**
     * 查询树
     *
     * @param queryTreeNodeDTO
     * @return
     * @throws Exception
     */
    public Records queryMessage(QueryTreeNodeDTO queryTreeNodeDTO) throws Exception {
        //返回数据
        Records records = new Records();
        List<ReTreeNodeVO> reTreeNodeVOS = new ArrayList<>();
        Integer type = queryTreeNodeDTO.getType();
        Integer typeId = queryTreeNodeDTO.getTypeId();
        Integer projectId = queryTreeNodeDTO.getProjectId();
        //校验格式
        if (type == null || typeId == null) {
            throw new XiaoShiException("参数错误");
        }
        if (projectId != null) {
            LambdaQueryWrapper<AssoProjectTreeNode> queryWrapper = new LambdaQueryWrapper<>();
            queryWrapper.eq(AssoProjectTreeNode::getProjectId, projectId);
            AssoProjectTreeNode assoProjectTreeNode = assoProjectTreeNodeService.getOne(queryWrapper, false);
            if (assoProjectTreeNode != null) {
                if (!assoProjectTreeNode.getValueId().equals(0)) {
                    queryTreeNodeDTO.setId(assoProjectTreeNode.getValueId());
                }
            }
        }
        List<TreeNodeVO> treeNodes = treeNodeMapper.getTreeNode(queryTreeNodeDTO);

        //如果根据名称查询
        if (queryTreeNodeDTO.getName() != null && !queryTreeNodeDTO.getName().trim().equals("")) {
            List<Integer> ids = new ArrayList<>();

            //当根据名称查出了节点
            if (treeNodes != null && treeNodes.size() != 0) {
                List<String> pathStrs = treeNodes.stream().map(TreeNodeVO::getPath).collect(Collectors.toList());
                List<Integer> nameIds = treeNodes.stream().map(TreeNodeVO::getId).collect(Collectors.toList());
                ids.addAll(nameIds);
                pathStrs.forEach(item -> {
                    if (item != null && !item.trim().equals("")) {
                        List<Integer> paths = Arrays.stream(item.split("/")).map(s -> {
                            if (!s.equals("")) {
                                return Integer.parseInt(s.trim());
                            } else return null;
                        }).collect(Collectors.toList());
                        ids.addAll(paths);
                    }
                });

                //返回树
                List<TreeNodeVO> treeNodeVOS = treeNodeMapper.getTreeNodeByIds(ids, false, null, null);
                this.loadTreeNode(treeNodeVOS);
                reTreeNodeVOS = this.reTrees(treeNodeVOS);
                records.setData(reTreeNodeVOS);
                return records;
            } else {
                records.setData(reTreeNodeVOS);
                return records;
            }
        }
        //返回树
        this.loadTreeNode(treeNodes);
        reTreeNodeVOS = this.reTrees(treeNodes);
        records.setData(reTreeNodeVOS);
        return records;
    }

    //装载树
    List<ReTreeNodeVO> reTrees(List<TreeNodeVO> treeNodes) {
        treeNodes = treeNodes.stream().sorted(Comparator.comparing(TreeNodeVO::getLevel).reversed())
                .collect(Collectors.toList());
        List<ReTreeNodeVO> reTreeNodeVOS = new ArrayList<>();
        for (TreeNodeVO treeNode : treeNodes) {
            ReTreeNodeVO reTreeNodeVO = new ReTreeNodeVO();
            BeanUtils.copyProperties(treeNode, reTreeNodeVO);
            List<String> pathNames = new ArrayList<>();
            if (treeNode.getPath() != null && !treeNode.getPath().trim().equals("")) {
                List<Integer> paths = Arrays.stream(treeNode.getPath().split("/")).map(s -> {
                    if (!s.equals("")) {
                        return Integer.parseInt(s.trim());
                    } else return null;
                }).collect(Collectors.toList());
                for (Integer tem : paths) {
                    TreeNodeVO treeNode1 = treeNodes.stream().filter(item -> item.getId().equals(tem)).findFirst().orElse(null);
                    if (treeNode1 != null) {
                        pathNames.add(treeNode1.getName());
                    }
                }

                if (pathNames.size() != 0) {
                    reTreeNodeVO.setPathName("/" + StringUtils.join(pathNames, "/"));
                }
            } else {

                reTreeNodeVO.setPathName("/");
            }
            List<ReTreeNodeVO> childReTreeNodeVOs = reTreeNodeVOS.stream().filter(item -> item.getParentId().equals(treeNode.getId())).collect(Collectors.toList());
            reTreeNodeVO.setChild(childReTreeNodeVOs);
            reTreeNodeVOS.removeAll(childReTreeNodeVOs);
            reTreeNodeVOS.add(reTreeNodeVO);
        }

        return reTreeNodeVOS;
    }

    /**
     * 新增架构
     *
     * @param object
     * @param files
     * @return
     */
    @Override
    public Object addMessage(Object object, List<MultipartFile> files) {
        //object to treeNodeDTO
        TreeNodeDTO treeNodeDTO = (TreeNodeDTO) object;
        //检测名称是否规范
        treeNodeDTO.setName(treeNodeDTO.getName().trim());
        //根据名称查询是否重复
        String name = treeNodeDTO.getName();
        Integer parentId = treeNodeDTO.getParentId();
        Integer type = treeNodeDTO.getType();
        Integer typeId = treeNodeDTO.getTypeId();
        LambdaQueryWrapper<TreeNode> queryWrapper = new LambdaQueryWrapper<>();
        queryWrapper.eq(TreeNode::getName, name);
        queryWrapper.eq(TreeNode::getParentId, parentId);
        queryWrapper.eq(TreeNode::getType, type);
        queryWrapper.eq(TreeNode::getTypeId, typeId);
        List<TreeNode> treeNodes = this.list(queryWrapper);
        if (treeNodes != null && treeNodes.size() != 0) {
            throw new XiaoShiException("名称不能重复！");
        }
        //获取登录人信息
        PersonnelVO personnelVO = new PersonnelVO();

        personnelVO = cacheUtils.getLoginUser(loginUtils.getId());

        //赋值
        TreeNode treeNode = new TreeNode();
        BeanUtils.copyProperties(treeNodeDTO, treeNode);
        //若父id为0，则代表这是顶层id
        if (parentId.equals(0)) {
            treeNode.setPath("");
            treeNode.setLevel(0);
        } else {//有父id，根据父id获取它的路径，然后加上父id拼接成该条路径
            TreeNode parentNode = this.getById(parentId);
            String parentPath = parentNode.getPath();
            if (parentPath != null) {
                //父id若为顶层id，则父id没有路径
                if (parentPath.equals("")) {
                    treeNode.setPath(parentId + "");
                    treeNode.setLevel(1);
                } else {
                    //父id不是顶层id，父id有路径
                    treeNode.setPath(parentPath + "/" + parentId);
                    treeNode.setLevel(parentNode.getLevel() + 1);
                }
            } else {
                throw new XiaoShiException("数据库中路径错误");
            }
        }
        treeNode.setCreateId(personnelVO.getId());
        treeNode.insert();
        //处理文件
        if (files != null && files.size() != 0) {
            try {
                List<String> guids = fileManagerService.uploadFileGetGuid(files);
                List<AssoTreeNodeFile> assoTreeNodeFiles = new ArrayList<>();
                for (String item : guids) {
                    AssoTreeNodeFile assoTreeNodeFile = new AssoTreeNodeFile();
                    assoTreeNodeFile.setTreeNodeId(treeNode.getId());
                    assoTreeNodeFile.setFileGuid(item);
                    assoTreeNodeFile.setCreateId(personnelVO.getId());
                    assoTreeNodeFiles.add(assoTreeNodeFile);
                }
                if (assoTreeNodeFiles != null && assoTreeNodeFiles.size() != 0) {
                    assoTreeNodeFileService.saveBatch(assoTreeNodeFiles);
                }
            } catch (Exception e) {

            }
        }
        //返回id
        return treeNode.getId();
    }

    /**
     * 删除架构
     *
     * @param ids
     * @return
     */
    @Override
    @Transactional(rollbackFor = Exception.class)
    public Object deleteMessage(List<Integer> ids) throws IOException {
        //检验参数
        if (ids == null || ids.size() == 0) {
            throw new XiaoShiException("参数错误");
        }
        //查询节点下的子节点以及自身id
        List<Integer> trueIds = new ArrayList<>();
        ids.forEach(item -> {
            QueryTreeNodeDTO queryTreeNodeDTO = new QueryTreeNodeDTO();
            queryTreeNodeDTO.setId(item);
            List<TreeNodeVO> treeNodes = treeNodeMapper.getTreeNode(queryTreeNodeDTO);
            List<Integer> tmpIds = treeNodes.stream().map(TreeNodeVO::getId).collect(Collectors.toList());
            trueIds.addAll(tmpIds);
        });


        //根据架构id删除架构和文件关联
        LambdaQueryWrapper<AssoTreeNodeFile> queryWrapper = new LambdaQueryWrapper<>();
        queryWrapper.in(AssoTreeNodeFile::getTreeNodeId, trueIds);
        List<AssoTreeNodeFile> assoTreeNodeFiles = assoTreeNodeFileService.list(queryWrapper);
        List<String> guids = assoTreeNodeFiles.stream().map(AssoTreeNodeFile::getFileGuid).collect(Collectors.toList());
        //TODO 根据guids删除文件
        if (guids.size() != 0) {
            fileManagerService.deleteFileFromFMS(guids);
        }
        //删除架构和文件关联表
        assoTreeNodeFiles.remove(queryWrapper);
        //根据架构id删除架构数据
        this.removeBatchByIds(trueIds);
        return ids;
    }

    /**
     * 更新架构
     *
     * @param object
     * @param files
     * @return
     */
    @Override
    public Object updateMessage(Object object, List<MultipartFile> files) {
        //object to treeNode
        UpdateTreeNodeDTO updateTreeNodeDTO = (UpdateTreeNodeDTO) object;
        //检测传入参数合理性
        if (updateTreeNodeDTO == null || updateTreeNodeDTO.getId() == null) {
            throw new XiaoShiException("传入参数不能为空");
        }
        //获取登录人信息
        PersonnelVO personnelVO = new PersonnelVO();

        personnelVO = cacheUtils.getLoginUser(loginUtils.getId());

        TreeNode treeNode = this.getById(updateTreeNodeDTO.getId());
        //检查名称是否规范
        updateTreeNodeDTO.setName(updateTreeNodeDTO.getName().trim());
        //根据名称查询是否重复
        String name = updateTreeNodeDTO.getName();
        LambdaQueryWrapper<TreeNode> queryWrapper = new LambdaQueryWrapper<>();
        queryWrapper.eq(TreeNode::getName, name);
        List<TreeNode> treeNodes = this.list(queryWrapper);
        if (!updateTreeNodeDTO.getName().equals(treeNode.getName()) && treeNodes.size() != 0) {
            throw new XiaoShiException("节点名称重复");
        }
        BeanUtils.copyProperties(updateTreeNodeDTO, treeNode);
        Integer parentId = updateTreeNodeDTO.getParentId();
        //若父id为0，则代表这是顶层id
        if (parentId.equals(0)) {
            treeNode.setPath("");
            treeNode.setLevel(0);
        } else {//有父id，根据父id获取它的路径，然后加上父id拼接成该条路径
            TreeNode parentNode = this.getById(parentId);
            String parentPath = parentNode.getPath();
            if (parentPath != null) {
                //父id若为顶层id，则父id没有路径
                if (parentPath.equals("")) {
                    treeNode.setPath(parentId + "/");
                    treeNode.setLevel(1);
                } else {
                    //父id不是顶层id，父id有路径
                    treeNode.setPath(parentPath + parentId + "/");
                    treeNode.setLevel(parentNode.getLevel() + 1);
                }
            } else {
                throw new XiaoShiException("数据库中路径错误");
            }
        }
        //数据入表
        treeNode.updateById();
        /**
         * 与架构节点有关文件的处理
         */
        //根据架构id查询对应的附件id
        LambdaQueryWrapper<AssoTreeNodeFile> wrapper = new LambdaQueryWrapper<>();
        wrapper.eq(AssoTreeNodeFile::getTreeNodeId, updateTreeNodeDTO.getId());
        List<AssoTreeNodeFile> assoFiles = assoTreeNodeFileService.list(wrapper);
        List<String> fileGuIds = assoFiles.stream().map(AssoTreeNodeFile::getFileGuid).collect(Collectors.toList());
        //获取更新后的附件ids
        List<String> updateFileGuIds = new ArrayList<>();
        if (updateTreeNodeDTO.getGuids() != null && updateTreeNodeDTO.getGuids().size() != 0) {
            updateFileGuIds = updateTreeNodeDTO.getGuids();
            fileGuIds.retainAll(updateFileGuIds);
        }
        //做差获得被删除的文件id
        if (fileGuIds.size() != 0) {
            //根据文件id删除架构与文件关联表记录
            LambdaQueryWrapper<AssoTreeNodeFile> deleteWrapper = new LambdaQueryWrapper<>();
            deleteWrapper.in(AssoTreeNodeFile::getFileGuid, fileGuIds);
            assoTreeNodeFileService.remove(deleteWrapper);
            //远程删除服务器上的文件
            try {
                fileManagerService.deleteFileFromFMS(fileGuIds);
            } catch (Exception e) {

            }
        }
        //处理文件
        if (files != null && files.size() != 0) {
            try {
                List<String> guids = fileManagerService.uploadFileGetGuid(files);
                List<AssoTreeNodeFile> assoTreeNodeFiles = new ArrayList<>();
                for (String item : guids) {
                    AssoTreeNodeFile assoTreeNodeFile = new AssoTreeNodeFile();
                    assoTreeNodeFile.setTreeNodeId(treeNode.getId());
                    assoTreeNodeFile.setFileGuid(item);
                    assoTreeNodeFile.setCreateId(personnelVO.getId());
                    assoTreeNodeFiles.add(assoTreeNodeFile);
                }
                if (assoTreeNodeFiles != null && assoTreeNodeFiles.size() != 0) {
                    assoTreeNodeFileService.saveBatch(assoTreeNodeFiles);
                }
            } catch (Exception e) {

            }
        }
        //返回id
        return treeNode.getId();
    }


    @Override
    public GroupVO getGroup(GroupRequest groupRequest, String tableName) throws Exception {
        return null;
    }


    @Override
    public Object addMessage(Object object) {
        return null;
    }


    @Override
    public Object updateMessage(Object object) {
        return null;
    }


    private void loadTreeNode(List<TreeNodeVO> treeNodeVOS) throws Exception {
        List<String> createIds = new ArrayList<>();
        List<Integer> ids = new ArrayList<>();
        treeNodeVOS.forEach(
                item -> {
                    if (item.getCreateId() != null) {
                        createIds.add(item.getCreateId());
                    }
                    if (item.getId() != null) {
                        ids.add(item.getId());
                    }
                }
        );

        if (!CollectionUtils.isEmpty(treeNodeVOS)) {
            for (TreeNodeVO nodeVO : treeNodeVOS) {
                Integer type = nodeVO.getType();
                if (type != null) {
                    if (type == 1 || type == 2) {
                        Long relevantProductNum = esProductPatentService.selectRelevantTreeNodeNum(nodeVO.getId(),type);
                        nodeVO.setRelevantProductNum(relevantProductNum);
                    }
                }
            }
        }


        List<Personnel> personnels = new ArrayList<>();
        List<String> guids = new ArrayList<>();
        List<SystemFile> systemFiles = new ArrayList<>();

        List<AssoTreeNodeFile> assoTreeNodeFiles = new ArrayList<>();

        if (ids.size() != 0) {
            //根据架构id获得架构与文件关联表
            LambdaQueryWrapper<AssoTreeNodeFile> queryWrapper = new LambdaQueryWrapper<>();
            queryWrapper.in(AssoTreeNodeFile::getTreeNodeId, ids);
            assoTreeNodeFiles = assoTreeNodeFileService.list(queryWrapper);
            guids = assoTreeNodeFiles.stream().map(AssoTreeNodeFile::getFileGuid).collect(Collectors.toList());
        }

        //查询创建人名称
        if (createIds.size() != 0) {
            String res = permissionService.getPersonnelByIdsFromPCS(createIds);
            JSONObject jsonObject = JSONObject.parseObject(res);
            personnels = JSONObject.parseArray(jsonObject.getString("data"), Personnel.class);
        }

        //查询文件
        if (guids.size() != 0) {
            String res = fileManagerService.getSystemFileFromFMS(guids);
            if (res != null && !res.equals("")) {
                systemFiles = JSONObject.parseArray(res, SystemFile.class);
            }
        }

        //装载信息
        for (TreeNodeVO treeNodeVO : treeNodeVOS) {
            //装载人员信息
            Personnel personnel = personnels.stream().filter(item -> item.getId().toString().equals(treeNodeVO.getCreateId())).findFirst().orElse(null);
            if (personnel != null) {
                treeNodeVO.setCreateName(personnel.getPersonnelName());
            }
            //装载文件信息
            List<AssoTreeNodeFile> assoTreeNodeFilesTemp = assoTreeNodeFiles.stream().filter(item -> item.getTreeNodeId().equals(treeNodeVO.getId())).collect(Collectors.toList());
            if (assoTreeNodeFilesTemp.size() != 0) {
                List<String> guidTemp = assoTreeNodeFilesTemp.stream().map(AssoTreeNodeFile::getFileGuid).collect(Collectors.toList());
                if (guidTemp.size() != 0) {
                    List<SystemFile> systemFileTemp = systemFiles.stream().filter(item -> guidTemp.contains(item.getGuid())).collect(Collectors.toList());
                    if (systemFileTemp.size() != 0) {
                        treeNodeVO.setSystemFileList(systemFileTemp);
                    }
                }
            }
        }
    }


    //复制节点
    @Transactional(rollbackFor = Exception.class)
    public void copy(CopyTreeNodeDTO copyTreeNodeDTO) {
        Integer fromTypeId = copyTreeNodeDTO.getFromTypeId();
        Integer fromType = copyTreeNodeDTO.getFromType();
        List<Integer> fromNodeIds = copyTreeNodeDTO.getFromNodeIds();
        Integer toTypeId = copyTreeNodeDTO.getToTypeId();
        Integer toType = copyTreeNodeDTO.getToType();
        Integer toId = copyTreeNodeDTO.getToNodeId();
        Boolean ifCopyChild = copyTreeNodeDTO.getIfCopyChild();
        Boolean ifDelete = copyTreeNodeDTO.getIfDelete();

        List<TreeNodeVO> fromTreeNodeVOS = new ArrayList<>();

        //判断是否复制全部
        if (fromNodeIds == null || fromNodeIds.size() == 0) {
            fromTreeNodeVOS = treeNodeMapper.getTreeNodeByIds(null, false, fromType, fromTypeId);
        } else {
            fromTreeNodeVOS = treeNodeMapper.getTreeNodeByIds(fromNodeIds, ifCopyChild, null, null);
        }
//根据id查出树

        List<ReTreeNodeVO> fromReTreeNodeVOs = this.reTrees(fromTreeNodeVOS);
        Integer level = 0;

        //根据copyId 查询节点
        if (toId != null) {
            TreeNode treeNode = this.getById(toId);
            level = treeNode.getLevel();
            for (ReTreeNodeVO item : fromReTreeNodeVOs) {
                item.setParentId(toId);
                item.setPath(treeNode.getPath() + treeNode.getId() + "/");
                item.setLevel(level + 1);
                item.setType(treeNode.getType());
                item.setTypeId(treeNode.getTypeId());
            }
        } else {
            for (ReTreeNodeVO item : fromReTreeNodeVOs) {
                item.setParentId(0);
                item.setPath("");
                item.setLevel(level);
                item.setType(toType);
                item.setTypeId(toTypeId);
            }

        }

        List<TreeNodeVO> toTreeNodeVOs = new ArrayList<>();
        if (toId != null) {
            QueryTreeNodeDTO queryTreeNodeDTO2 = new QueryTreeNodeDTO();
            queryTreeNodeDTO2.setId(toId);
            toTreeNodeVOs = treeNodeMapper.getTreeNode(queryTreeNodeDTO2);
        } else {
            toTreeNodeVOs = treeNodeMapper.getTreeNodeByIds(null, true, toType, toTypeId);
        }
        while (fromReTreeNodeVOs.size() != 0) {
            List<ReTreeNodeVO> reTreeNodeVOS = new ArrayList<>();
            for (ReTreeNodeVO reTreeNodeVO : fromReTreeNodeVOs) {
                //根据父id查找子节点
                TreeNodeVO treeNodeVO = toTreeNodeVOs.stream().filter(item -> item.getParentId().equals(reTreeNodeVO.getParentId()) && item.getName().equals(reTreeNodeVO.getName())).findFirst().orElse(null);

                //当有相同节点时
                if (treeNodeVO != null) {
                    BeanUtils.copyProperties(treeNodeVO, reTreeNodeVO);

                } else {
                    TreeNode treeNode1 = new TreeNode();
                    BeanUtils.copyProperties(reTreeNodeVO, treeNode1);
                    treeNode1.setId(null);
                    treeNode1.insert();
                    reTreeNodeVO.setId(treeNode1.getId());
                }
//TODO 复制相关专利
                List<ReTreeNodeVO> childNodes = reTreeNodeVO.getChild();
                if (childNodes != null && childNodes.size() > 0) {
                    childNodes.forEach(item -> {
                        item.setParentId(reTreeNodeVO.getId());
                        item.setPath(reTreeNodeVO.getPath() + reTreeNodeVO.getId());
                        item.setTypeId(reTreeNodeVO.getTypeId());
                        item.setType(reTreeNodeVO.getType());
                        item.setLevel(reTreeNodeVO.getLevel() + 1);
                    });
                    reTreeNodeVOS.addAll(childNodes);

                }
            }
            fromReTreeNodeVOs = reTreeNodeVOS;
        }
    }

    public void loadPath(List<TreeNodeVO> treeNodeVOS) {

        //装载所有的父节点id
        List<Integer> parentIds = new ArrayList<>();
        treeNodeVOS.forEach(item -> {
            if (item.getPath() != null && !item.getPath().trim().equals("")) {
                List<Integer> pathIds = Arrays.stream(item.getPath().split("/")).map(s -> {
                    if (!s.equals("")) {
                        return Integer.parseInt(s.trim());
                    } else {
                        return null;
                    }
                }).collect(Collectors.toList());
                parentIds.addAll(pathIds);
            }
        });

        //根据父节点id查询
        List<TreeNode> parentNodes = new ArrayList<>();
        if (parentIds.size() != 0) {
            LambdaQueryWrapper<TreeNode> queryWrapper = new LambdaQueryWrapper<>();
            queryWrapper.in(TreeNode::getId, parentIds);
            parentNodes = this.list(queryWrapper);
        }

        //装载路径
        for (TreeNodeVO treeNode : treeNodeVOS) {
            List<String> pathNames = new ArrayList<>();
            if (treeNode.getPath() != null && !treeNode.getPath().trim().equals("")) {
                List<Integer> paths = Arrays.stream(treeNode.getPath().split("/")).map(s -> {
                    if (!s.equals("")) {
                        return Integer.parseInt(s.trim());
                    } else return null;
                }).collect(Collectors.toList());
                for (Integer tem : paths) {
                    TreeNode treeNode1 = parentNodes.stream().filter(item -> item.getId().equals(tem)).findFirst().orElse(null);
                    if (treeNode1 != null) {
                        pathNames.add(treeNode1.getName());
                    }
                }

                if (pathNames.size() != 0) {
                    treeNode.setPathName("/" + StringUtils.join(pathNames, "/"));
                }
            } else {

                treeNode.setPathName("/");
            }

        }
    }


    /**
     * 查询树
     *
     * @param queryTreeNodeDTO
     * @return
     * @throws Exception
     */
    public Records queryAllPath(QueryAllTreePathDTO queryTreeNodeDTO) throws Exception {
        //校验
        if (queryTreeNodeDTO == null || queryTreeNodeDTO.getType() == null || queryTreeNodeDTO.getTypeId() == null) {
            throw new XiaoShiException("参数错误");
        }

        //返回数据
        Records records = new Records();

        LambdaQueryWrapper<TreeNode> queryWrapper = new LambdaQueryWrapper<>();
        queryWrapper.eq(TreeNode::getType, queryTreeNodeDTO.getType())
                .eq(TreeNode::getTypeId, queryTreeNodeDTO.getTypeId()).orderByAsc(TreeNode::getLevel);
        List<TreeNode> treeNodes = this.list(queryWrapper);
        List<TreePathVO> treeNodeVOS = new ArrayList<>();
        TreePathVO treePathFirst = new TreePathVO();
        treePathFirst.setId(0);
        treePathFirst.setPath("/");
        treePathFirst.setPathName("/");
        treeNodeVOS.add(treePathFirst);
        //装载路径
        for (TreeNode treeNode : treeNodes) {
            TreePathVO treePathVO = new TreePathVO();
            treePathVO.setId(treeNode.getId());
            treePathVO.setPath(treeNode.getPath() + treeNode.getId() + "/");
            List<String> pathNames = new ArrayList<>();
            if (treeNode.getPath() != null && !treeNode.getPath().trim().equals("")) {
                List<Integer> paths = Arrays.stream(treeNode.getPath().split("/")).map(s -> {
                    if (!s.equals("")) {
                        return Integer.parseInt(s.trim());
                    } else return null;
                }).collect(Collectors.toList());
                for (Integer tem : paths) {
                    TreeNode treeNode1 = treeNodes.stream().filter(item -> item.getId().equals(tem)).findFirst().orElse(null);
                    if (treeNode1 != null) {
                        pathNames.add(treeNode1.getName());
                    }
                }
                if (pathNames.size() != 0) {
                    treePathVO.setPathName("/" + StringUtils.join(pathNames, "/") + "/" + treeNode.getName() + "/");
                }
            } else {
                treePathVO.setPathName("/" + treeNode.getName() + "/");
            }
            treeNodeVOS.add(treePathVO);
        }
        records.setData(treeNodeVOS);
        return records;
    }


    public List<String> getIdByNames(List<String> values, Integer fieldId, Integer type) {
        if (type == 6) {
            type = 4;
        }
        Integer newType = type;
        List<String> ids = new ArrayList<>();
        values.forEach(item -> {
            List<String> nodes = cn.cslg.pas.common.utils.StringUtils.changeStringToString(item, "\\\\");
            TreeNode lastTreeNode = null;
            for (int i = 0; i < nodes.size(); i++) {
                LambdaQueryWrapper<TreeNode> queryWrapper = new LambdaQueryWrapper<>();
                queryWrapper.eq(TreeNode::getTypeId, fieldId)
                        .eq(TreeNode::getType, newType)
                        .eq(TreeNode::getName, nodes.get(i))
                        .eq(TreeNode::getLevel, i);
                if (lastTreeNode == null) {
                    queryWrapper.eq(TreeNode::getParentId, 0);
                } else {
                    queryWrapper.eq(TreeNode::getParentId, lastTreeNode.getId());
                }
                TreeNode treeNode = this.getOne(queryWrapper);
                if (treeNode == null) {
                    treeNode = new TreeNode();
                    treeNode.setLevel(i);
                    treeNode.setName(nodes.get(i));
                    treeNode.setType(newType);
                    treeNode.setTypeId(fieldId);
                    treeNode.setParentId(0);
                    treeNode.setPath("");
                    if (lastTreeNode != null) {
                        treeNode.setParentId(lastTreeNode.getId());
                        if (lastTreeNode.getParentId() == 0) {
                            treeNode.setPath("" + lastTreeNode.getId());

                        } else {
                            treeNode.setPath(lastTreeNode.getPath() + "/" + lastTreeNode.getId());
                        }
                    }
                    treeNode.insert();

                }
                lastTreeNode = treeNode;
                if (nodes.size() - 1 == i) {
                    ids.add(treeNode.getId().toString());
                }
            }


        });
        return ids;
    }

    //
    public List<String> getIdByNames2(List<String> values, Integer fieldId, Integer conditionId) {

        List<String> valuesIds = new ArrayList<>();
        for (String value : values) {
            String[] valueQs = value.split("\\\\");
            TreeNode treeNode = null;
            for (int i = 0; i < valueQs.length; i++) {
                String valueQ = valueQs[i];
                treeNode = this.getTreeNodeByName(valueQ, i, fieldId, treeNode, conditionId);
                if (i == valueQs.length - 1) {
                    if (!valuesIds.contains(treeNode.getId())) {
                        valuesIds.add(treeNode.getId().toString());
                    }
                }
            }
        }
        return valuesIds;
    }


    public TreeNode getTreeNodeByName(String value, Integer level, Integer fieldId, TreeNode parentTreeNode, Integer conditionId) {
        Integer parentId = 0;
        if (parentTreeNode != null) {
            parentId = parentTreeNode.getId();
        }

        //根据名称查询
        LambdaQueryWrapper<TreeNode> queryWrapper = new LambdaQueryWrapper<>();
        queryWrapper.eq(TreeNode::getName, value)
                .eq(TreeNode::getLevel, level)
                .eq(TreeNode::getParentId, parentId)
                .eq(TreeNode::getType, 4)
                .eq(TreeNode::getTypeId, fieldId);
        TreeNode treeNode = this.getOne(queryWrapper, false);
        if (treeNode == null) {
            treeNode = new TreeNode();
            treeNode.setName(value);
            treeNode.setType(4);
            treeNode.setParentId(parentId);
            treeNode.setLevel(level);
            treeNode.setTypeId(fieldId);
            if (parentTreeNode != null) {
                treeNode.setPath(parentTreeNode.getPath() + "/" + parentTreeNode.getId());
            } else {
                treeNode.setPath("");
            }
            treeNode.insert();
        }
        return treeNode;
    }


    /**
     * 添加自定义树节点
     *
     * @param treeNodeDTO
     * @return
     */
    public TreeNode addTreeNode(TreeNodeDTO treeNodeDTO) {
        //object to treeNodeDTO

        //检测名称是否规范
        treeNodeDTO.setName(treeNodeDTO.getName().trim());
        //根据名称查询是否重复
        String name = treeNodeDTO.getName();
        Integer parentId = treeNodeDTO.getParentId();
        Integer type = treeNodeDTO.getType();
        Integer typeId = treeNodeDTO.getTypeId();
        LambdaQueryWrapper<TreeNode> queryWrapper = new LambdaQueryWrapper<>();
        queryWrapper.eq(TreeNode::getName, name);
        queryWrapper.eq(TreeNode::getParentId, parentId);
        queryWrapper.eq(TreeNode::getType, type);
        queryWrapper.eq(TreeNode::getTypeId, typeId);
        List<TreeNode> treeNodes = this.list(queryWrapper);
        if (treeNodes != null && treeNodes.size() != 0) {
            throw new XiaoShiException("名称不能重复！");
        }

        //赋值
        TreeNode treeNode = new TreeNode();
        BeanUtils.copyProperties(treeNodeDTO, treeNode);
        //若父id为0，则代表这是顶层id
        if (parentId.equals(0)) {
            treeNode.setPath("");
            treeNode.setLevel(0);
        } else {//有父id，根据父id获取它的路径，然后加上父id拼接成该条路径
            TreeNode parentNode = this.getById(parentId);
            String parentPath = parentNode.getPath();
            if (parentPath != null) {
                //父id若为顶层id，则父id没有路径
                if (parentPath.equals("")) {
                    treeNode.setPath(parentId + "");
                    treeNode.setLevel(1);
                } else {
                    //父id不是顶层id，父id有路径
                    treeNode.setPath(parentPath + "/" + parentId);
                    treeNode.setLevel(parentNode.getLevel() + 1);
                }
            } else {
                throw new XiaoShiException("数据库中路径错误");
            }
        }
        treeNode.setCreateId(treeNodeDTO.getPersonId());
        treeNode.insert();

        //返回id
        return treeNode;
    }
}