架构查询

src/main/java/cn/cslg/pas/common/vo/ReTreeNodeVO.java

@@ -0,0 +1,48 @@
+package cn.cslg.pas.common.vo;
+
+import cn.cslg.pas.common.model.cronModel.SystemFile;
+import cn.hutool.core.date.DateTime;
+import io.swagger.v3.oas.annotations.media.Schema;
+import lombok.Data;
+
+import java.util.List;
+
+/**
+ * 返回架构VO
+ * @Author lirj
+ * @Date 2023/11/3
+ */
+@Data
+public class ReTreeNodeVO {
+    @Schema(description = "id")
+    private Integer id;
+    @Schema(description = "节点名称")
+    private String name;
+    /**
+     * (1产品类别，2产品，3技术分类，4自定义树)
+     */
+    @Schema(description = "类型")
+    private Integer type;
+    @Schema(description = "父id")
+    private Integer parentId;
+    /**
+     * (所属产品/产品类别/自定义树/技术分类)
+     */
+    @Schema(description = "抽象id")
+    private Integer typeId;
+    @Schema(description = "路径名称")
+    private String pathName;
+    @Schema(description = "路径")
+    private String path;
+    @Schema(description = "层级")
+    private Integer level;
+    @Schema(description = "子节点")
+    private List<ReTreeNodeVO> child;
+    @Schema(description = "创建人id")
+    private String createId;
+    @Schema(description = "创建时间")
+    private DateTime createTime;
+
+    @Schema(description = "文件信息")
+    private List<SystemFile> systemFileList;
+}

src/main/java/cn/cslg/pas/common/vo/business/TreeNodeVO.java

@@ -6,6 +6,7 @@ import com.baomidou.mybatisplus.annotation.TableField;
 import io.swagger.v3.oas.annotations.media.Schema;
 import lombok.Data;
 
+import java.util.Date;
 import java.util.List;
 
 /**
@@ -33,6 +34,8 @@ public class TreeNodeVO {
     private Integer typeId;
     @Schema(description = "路径")
     private String path;
+    @Schema(description = "路径")
+    private String pathName;
     @Schema(description = "层级")
     private Integer level;
     @Schema(description = "创建人id")
@@ -40,7 +43,7 @@ public class TreeNodeVO {
     @Schema(description = "创建人")
     private String createName;
     @Schema(description = "创建时间")
-    private DateTime createTime;
+    private Date createTime;
 
     @Schema(description = "文件信息")
     private List<SystemFile> systemFileList;

src/main/java/cn/cslg/pas/controller/TreeNodeController.java

@@ -39,14 +39,20 @@ public class TreeNodeController {
     private BusinessFactory businessFactory;
 
 
+    @Operation(summary = "查询架构树")
+    @PostMapping("/queryTreeNodeTree")
+    public Response queryTreeNodeTree(QueryTreeNodeDTO queryTreeNodeDTO) throws Exception {
+        TreeNodeService  business = (TreeNodeService) businessFactory.getClass("treeNodeService");
+        Records records = business.queryMessage(queryTreeNodeDTO);
+        return Response.success(records);
+    }
     @Operation(summary = "查询架构")
     @PostMapping("/queryTreeNode")
-    public String queryTreeNode(QueryTreeNodeDTO queryTreeNodeDTO) throws Exception {
+    public Response queryTreeNode(StringRequest stringRequest) throws Exception {
         TreeNodeService  business = (TreeNodeService) businessFactory.getClass("treeNodeService");
-        business.queryMessage(queryTreeNodeDTO);
-        return "";
+        Records records = (Records)business.queryMessage(stringRequest);
+        return Response.success(records);
     }
-
     @Operation(summary = "新增架构")
     @PostMapping("/addTreeNode")
     public Response addTreeNode(String treeNode, List<MultipartFile> files) throws Exception {

src/main/java/cn/cslg/pas/mapper/TreeNodeMapper.java

@@ -1,8 +1,11 @@
 package cn.cslg.pas.mapper;
 
+import cn.cslg.pas.common.dto.business.QueryTreeNodeDTO;
 import cn.cslg.pas.common.vo.business.TreeNodeVO;
 import cn.cslg.pas.domain.business.TreeNode;
+import cn.cslg.pas.service.query.Query;
 import com.baomidou.mybatisplus.core.mapper.BaseMapper;
+import org.apache.ibatis.annotations.Param;
 import org.springframework.stereotype.Repository;
 
 import java.util.List;
@@ -14,5 +17,8 @@ import java.util.List;
  */
 @Repository
 public interface TreeNodeMapper extends BaseMapper<TreeNode> {
-    List<TreeNodeVO> getTreeNode(String sql1, String sql2, String sql3);
+    List<TreeNodeVO> getTreeNode(@Param("queryTreeNodeDTO")QueryTreeNodeDTO queryTreeNodeDTO);
+    List<TreeNodeVO> getTreeNodeByIds(List<Integer> ids);
+    List<TreeNodeVO> getTreeNodes(String sql1,String sql2,String sql3);
+    public Long getTreeNodeCount(String sql);
 }

src/main/java/cn/cslg/pas/service/business/ProductService.java

@@ -17,7 +17,6 @@ import cn.cslg.pas.mapper.ProductMapper;
 import cn.cslg.pas.service.common.FileManagerService;
 import cn.cslg.pas.service.permissions.PermissionService;
 import cn.cslg.pas.service.query.FormatQueryService;
-import co.elastic.clients.elasticsearch.core.search.LaplaceSmoothingModel;
 import com.alibaba.fastjson.JSONObject;
 import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
 import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;

src/main/java/cn/cslg/pas/service/business/ReportProjectService.java

@@ -98,6 +98,31 @@ public class ReportProjectService extends ServiceImpl<ReportProjectMapper,Report
     @Transactional(rollbackFor = Exception.class)
     public Integer addMessage(Object object, List<MultipartFile> files) {
 
+        //校验参数
+
+        /**
+         * 装载project
+         */
+
+        /**
+         * 装载reportProject
+         */
+
+        /**
+         * 装载事件与project关联
+         */
+
+        /**
+         * 装载和附件关联
+         */
+
+
+        /**
+         * 装载核心结论
+         */
+
+
+
         return null;
     }
 

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

@@ -8,6 +8,8 @@ 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.domain.business.AssoTreeNodeFile;
 import cn.cslg.pas.domain.business.TreeNode;
@@ -22,6 +24,7 @@ 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;
@@ -30,6 +33,8 @@ 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;
 
@@ -65,31 +70,119 @@ public class TreeNodeService extends ServiceImpl<TreeNodeMapper, TreeNode> imple
 
     @Override
     public Object queryMessage(QueryRequest queryRequest) throws Exception {
+        List<String> sqls = formatQueryService.reSqls(queryRequest, "treeNode");
 
-        return null;
+        //根据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();
 
-    public Object queryMessage(QueryTreeNodeDTO queryTreeNodeDTO) throws Exception {
+        List<ReTreeNodeVO> reTreeNodeVOS = new ArrayList<>();
         Integer type = queryTreeNodeDTO.getType();
         Integer typeId = queryTreeNodeDTO.getTypeId();
-        Integer id = queryTreeNodeDTO.getId();
-        String name = queryTreeNodeDTO.getName();
+
         //校验格式
         if (type == null || typeId == null) {
             throw new XiaoShiException("参数错误");
         }
-        LambdaQueryWrapper<TreeNode> queryWrapper =new LambdaQueryWrapper<>();
-        queryWrapper.eq(TreeNode::getType,type)
-                    .eq(TreeNode::getTypeId,typeId);
-        if(id!=null){
-            queryWrapper.eq(TreeNode::getId,id);
+
+        //
+        List<TreeNodeVO> treeNodes = treeNodeMapper.getTreeNode(queryTreeNodeDTO);
+
+        //如果根据名称查询
+        if (queryTreeNodeDTO.getName() != null) {
+            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 -> Integer.parseInt(s.trim())).collect(Collectors.toList());
+                        ids.addAll(paths);
+                    }
+                });
+
+                //返回树
+                List<TreeNodeVO> treeNodeVOS = treeNodeMapper.getTreeNodeByIds(ids);
+                this.loadTreeNode(treeNodeVOS);
+                reTreeNodeVOS = this.reTrees(treeNodeVOS);
+                records.setData(reTreeNodeVOS);
+                return records;
+            } else {
+                records.setData(reTreeNodeVOS);
+                return records;
+            }
         }
-        if(name!=null){
-            queryWrapper.like(TreeNode::getName,name);
+
+        //返回树
+        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);
         }
-        List<TreeNode> treeNodes =new ArrayList<>();
-        return null;
+
+        return reTreeNodeVOS;
     }
 
     /**
@@ -303,21 +396,25 @@ public class TreeNodeService extends ServiceImpl<TreeNodeMapper, TreeNode> imple
         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 IOException {
         List<String> createIds = new ArrayList<>();
         List<Integer> ids = new ArrayList<>();
@@ -356,14 +453,13 @@ public class TreeNodeService extends ServiceImpl<TreeNodeMapper, TreeNode> imple
         //查询文件
         if (guids.size() != 0) {
             String res = fileManagerService.getSystemFileFromFMS(guids);
-            JSONObject jsonObject = JSONObject.parseObject(res);
-            systemFiles = JSONObject.parseArray(jsonObject.getString("data"), SystemFile.class);
+            systemFiles = JSONObject.parseArray(res, SystemFile.class);
         }
 
         //装载信息
         for (TreeNodeVO treeNodeVO : treeNodeVOS) {
             //装载人员信息
-            Personnel personnel = personnels.stream().filter(item -> item.getGuid().equals(treeNodeVO.getCreateId())).findFirst().orElse(null);
+            Personnel personnel = personnels.stream().filter(item -> item.getId().equals(treeNodeVO.getCreateId())).findFirst().orElse(null);
             if (personnel != null) {
                 treeNodeVO.setCreateName(personnel.getPersonnelName());
             }
@@ -380,4 +476,132 @@ public class TreeNodeService extends ServiceImpl<TreeNodeMapper, TreeNode> imple
             }
         }
     }
+
+
+    //复制节点
+    @Transactional(rollbackFor = Exception.class)
+    public void copy(Integer copiedId, Integer toId, Integer type, Integer typeId) {
+
+//根据id查出树
+        QueryTreeNodeDTO queryTreeNodeDTO1 = new QueryTreeNodeDTO();
+        queryTreeNodeDTO1.setId(copiedId);
+        List<TreeNodeVO> copiedTreeNodeVOs = treeNodeMapper.getTreeNode(queryTreeNodeDTO1);
+        List<ReTreeNodeVO> copiedReTreeNodeVOs = this.reTrees(copiedTreeNodeVOs);
+        Integer level = 0;
+
+        //根据copyId 查询节点
+        if (toId != null) {
+            TreeNode treeNode = this.getById(toId);
+            level = treeNode.getLevel();
+            for (ReTreeNodeVO item : copiedReTreeNodeVOs) {
+                item.setParentId(toId);
+                item.setPath(treeNode.getPath() + "/" + treeNode.getId());
+                item.setLevel(level);
+                item.setType(treeNode.getType());
+                item.setTypeId(treeNode.getTypeId());
+            }
+        } else {
+            for (ReTreeNodeVO item : copiedReTreeNodeVOs) {
+                item.setParentId(0);
+                item.setPath("");
+                item.setLevel(level);
+                item.setType(type);
+                item.setTypeId(typeId);
+            }
+
+        }
+
+        List<TreeNodeVO> toTreeNodeVOs = new ArrayList<>();
+        if (toId != null) {
+            QueryTreeNodeDTO queryTreeNodeDTO2 = new QueryTreeNodeDTO();
+            queryTreeNodeDTO2.setId(toId);
+            toTreeNodeVOs = treeNodeMapper.getTreeNode(queryTreeNodeDTO2);
+        }
+        while (copiedReTreeNodeVOs.size() != 0) {
+            List<ReTreeNodeVO> reTreeNodeVOS = new ArrayList<>();
+            for (ReTreeNodeVO reTreeNodeVO : copiedReTreeNodeVOs) {
+                //根据父id查找子节点
+                TreeNodeVO treeNodeVO = toTreeNodeVOs.stream().filter(item -> item.getParentId().equals(reTreeNodeVO.getParentId()) && reTreeNodeVO.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());
+                    });
+                    reTreeNodeVOS.addAll(childNodes);
+
+                }
+            }
+            copiedReTreeNodeVOs = 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("/");
+            }
+
+        }
+
+
+    }
 }

src/main/resources/jsons/treeNode.json

@@ -0,0 +1,76 @@
+[
+  {"name":"Id",
+    "type":"Integer",
+    "value":"id",
+    "field":"id",
+    "sqlField": "id",
+    "sqlClass": "getComSql",
+    "orderClass": "",
+    "groupClass":"",
+    "ifSearch":"true",
+    "ifGroup": "false",
+    "ifShow":"true"
+  },
+  {"name":"父Id",
+    "type":"Integer",
+    "value":"parentId",
+    "field":"parentId",
+    "sqlField": "parent_id",
+    "sqlClass": "getComSql",
+    "orderClass": "",
+    "groupClass":"",
+    "ifSearch":"true",
+    "ifGroup": "false",
+    "ifShow":"true"
+  },
+
+  {"name":"创建人",
+    "type":"String",
+    "value":"createName",
+    "field": "createName",
+    "sqlField": "create_id",
+    "sqlClass": "getCreateNameSql",
+    "orderClass": "getCreateNameOrder",
+    "groupClass":"getComGroup",
+    "ifSearch":"true",
+    "ifGroup": "false",
+    "ifShow":"true"
+
+  },
+  {"name":"创建时间",
+    "type":"DateTime",
+    "value":"createTime",
+    "field": "createTime",
+    "sqlField": "create_time",
+    "sqlClass": "getDateTimeSql",
+    "orderClass": "getComOrder",
+    "groupClass":"getTimeGroup",
+    "ifSearch":"true",
+    "ifGroup": "false",
+    "ifShow":"true"
+  },
+  {"name":"描述",
+    "type":"String",
+    "value":"description",
+    "field": "description",
+    "sqlField": "description",
+    "sqlClass": "getComSql",
+    "orderClass": "getComOrder",
+    "ifSearch":"true",
+    "ifGroup": "false",
+    "ifShow":"true"
+
+  },
+  {"name":"名称",
+    "type":"String",
+    "value":"name",
+    "field": "name",
+    "sqlField": "name",
+    "sqlClass": "getLikeSql",
+    "orderClass": "getComOrder",
+    "groupClass":"getComGroup",
+    "ifSearch":"true",
+    "ifGroup": "false",
+    "ifShow":"true"
+  }
+]

src/main/resources/mapper/TreeNodeMapper.xml

@@ -2,4 +2,53 @@
 <!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd" >
 <mapper namespace="cn.cslg.pas.mapper.TreeNodeMapper">
     <!--namespace根据自己需要创建的的mapper的路径和名称填写-->
+    <select id="getTreeNode" resultType="cn.cslg.pas.common.vo.business.TreeNodeVO">
+        select *
+        from tree_node as tree
+        <where>
+        <if test="queryTreeNodeDTO.type!=null">
+            tree.type=#{queryTreeNodeDTO.type}
+        </if>
+        <if  test="queryTreeNodeDTO.typeId!=null">
+            and tree.type_id=#{queryTreeNodeDTO.typeId}
+        </if>
+<if test="queryTreeNodeDTO.id!=null">
+    and (tree.id=#{queryTreeNodeDTO.id} or  FIND_IN_SET(#{queryTreeNodeDTO.id},REPLACE(tree.path,'/',',')))
+</if>
+        <if test="queryTreeNodeDTO.name!=null">
+            and tree.name like   concat('%', #{queryTreeNodeDTO.name}, '%')
+        </if>
+
+        </where>
+    </select>
+
+
+
+    <select id="getTreeNodeByIds" resultType="cn.cslg.pas.common.vo.business.TreeNodeVO">
+        select *
+        from tree_node as tree where id in
+        <foreach collection="ids" item="id" index="index" open="(" close=")" separator=",">
+            #{id}
+        </foreach>
+
+    </select>
+
+
+    <select id="getTreeNodes"  resultType="cn.cslg.pas.common.vo.business.TreeNodeVO">
+        select id,name,description,path,level ,create_id as createId,create_time as createTime from tree_node
+
+        <if test="sql1!=''">
+
+            where    ${sql1}
+        </if>
+
+        ${sql2} ${sql3}
+    </select>
+
+    <select id="getTreeNodeCount" resultType="java.lang.Long">
+        select count(*) from tree_node
+        <if test="sql!=''">
+            where    ${sql}
+        </if>
+    </select>
 </mapper>

src/test/java/cn/cslg/pas/service/TreeNodeServiceTests.java

@@ -1,35 +1,63 @@
 package cn.cslg.pas.service;
 
+import cn.cslg.pas.common.dto.business.QueryTreeNodeDTO;
+import cn.cslg.pas.common.model.cronModel.Records;
+import cn.cslg.pas.common.model.request.OrderDTO;
+import cn.cslg.pas.common.model.request.StringRequest;
 import cn.cslg.pas.common.utils.Response;
-import cn.cslg.pas.controller.TreeNodeController;
+import cn.cslg.pas.common.vo.ReTreeNodeVO;
+import cn.cslg.pas.service.business.TreeNodeService;
+import cn.cslg.pas.service.business.es.EsService;
 import org.junit.Assert;
 import org.junit.jupiter.api.Test;
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.boot.test.context.SpringBootTest;
-import org.springframework.web.multipart.MultipartFile;
 
+import java.util.ArrayList;
 import java.util.List;
 
 /**
- * @Author xiexiang
- * @Date 2023/11/3
+ * @author chenyu
+ * @date 2023/9/6
  */
 @SpringBootTest
 public class TreeNodeServiceTests {
     @Autowired
-    private TreeNodeController treeNodeController;
+    private TreeNodeService treeNodeService;
 
     @Test
-    void update() throws Exception {
-        List<MultipartFile> files = null;
-        String treeNode = "{\n" +
-                "    \"id\": 3,\n" +
-                "    \"name\": \"名称8\",\n" +
-                "    \"parentId\": 1,\n" +
-                "    \"description\": \"将名称2改成名称8，其余不变\",\n" +
-                "    \"guids\": []\n" +
-                "}";
-        Response response = treeNodeController.updateTreeNode(treeNode, files);
-        Assert.assertEquals(200,Integer.parseInt(response.getCode().toString()));
+    void addIoc() throws Exception {
+        QueryTreeNodeDTO queryTreeNodeDTO = new QueryTreeNodeDTO();
+        queryTreeNodeDTO.setType(1);
+        queryTreeNodeDTO.setTypeId(2);
+        queryTreeNodeDTO.setName("名称10");
+//        List<ReTreeNodeVO> reTreeNodeVOS = treeNodeService.queryMessage(queryTreeNodeDTO);
+//        System.out.println(reTreeNodeVOS);
+    }
+
+    @Test
+    void testCopy() throws Exception {
+        treeNodeService.copy(2, null, 1, 4);
+    }
+
+    @Test
+    void query() throws Exception {
+        StringRequest queryRequest = new StringRequest();
+        queryRequest.setSearchQuery("parentId=2");
+        List<OrderDTO> dtos = new ArrayList<>();
+        OrderDTO orderDTO1 = new OrderDTO();
+        orderDTO1.setOrderBy("name");
+        orderDTO1.setOrderType(0);
+        OrderDTO orderDTO2 = new OrderDTO();
+        orderDTO2.setOrderBy("createName");
+        orderDTO2.setOrderType(1);
+        dtos.add(orderDTO1);
+//        dtos.add(orderDTO2);
+        queryRequest.setOrderDTOList(dtos);
+        queryRequest.setCurrent(Long.parseLong("1"));
+        queryRequest.setSize(Long.parseLong("10"));
+        Records records = (Records)treeNodeService.queryMessage(queryRequest);
+
+        Assert.assertEquals(Integer.parseInt(records.getTotal().toString()),1);
     }
 }