完成查询权要树接口

PAS/src/main/java/cn/cslg/pas/common/PatentRightContent.java

@@ -0,0 +1,39 @@
+package cn.cslg.pas.common;
+
+import lombok.Data;
+import lombok.experimental.Accessors;
+
+import java.io.Serializable;
+import java.util.List;
+
+/**
+ * 权要的文本树类
+ *
+ * @author chenyu
+ * @date 2023/8/31
+ */
+@Accessors(chain = true)
+@Data
+public class PatentRightContent implements Serializable {
+    /**
+     * 排序号
+     */
+    private Integer sort;
+    /**
+     * 父权要的排序号
+     */
+    private List<Integer> parentSorts;
+    /**
+     * 权利要求原文
+     */
+    private String content;
+    /**
+     * 权利要求译文
+     */
+    private String contentOut;
+    /**
+     * 类型
+     */
+    private Integer type;
+
+}

PAS/src/main/java/cn/cslg/pas/common/TreeBuild.java

@@ -0,0 +1,83 @@
+package cn.cslg.pas.common;
+
+import java.util.ArrayList;
+import java.util.List;
+
+/**
+ * @author chenyu
+ * @date 2023/8/31
+ */
+public class TreeBuild {
+
+    // 保存参与构建树形的所有数据（通常数据库查询结果）
+    public List<TreeNode> nodeList = new ArrayList<>();
+
+    /**
+     * 构造方法
+     *
+     * @param nodeList 将数据集合赋值给nodeList，即所有数据作为所有节点。
+     */
+    public TreeBuild(List<TreeNode> nodeList) {
+        this.nodeList = nodeList;
+    }
+
+    /**
+     * 获取需构建的所有根节点（顶级节点） "-1"
+     *
+     * @return 所有根节点List集合
+     */
+    public List<TreeNode> getRootNode() {
+        // 保存所有根节点（所有根节点的数据）
+        List<TreeNode> rootNodeList = new ArrayList<>();
+        // treeNode：查询出的每一条数据（节点）
+        for (TreeNode treeNode : nodeList) {
+            // 判断当前节点是否为根节点，此处注意：若parentId类型是String，则要采用equals()方法判断。
+            if (treeNode.getParentSorts().contains(-1)) {
+                // 是，添加
+                rootNodeList.add(treeNode);
+            }
+        }
+        return rootNodeList;
+    }
+
+    /**
+     * 根据每一个顶级节点（根节点）进行构建树形结构
+     *
+     * @return 构建整棵树
+     */
+    public List<TreeNode> buildTree() {
+        // treeNodes：保存一个顶级节点所构建出来的完整树形
+        List<TreeNode> treeNodes = new ArrayList<TreeNode>();
+        // getRootNode()：获取所有的根节点
+        for (TreeNode treeRootNode : getRootNode()) {
+            // 将顶级节点进行构建子树
+            treeRootNode = buildChildTree(treeRootNode);
+            // 完成一个顶级节点所构建的树形，增加进来
+            treeNodes.add(treeRootNode);
+        }
+        return treeNodes;
+    }
+
+    /**
+     * 递归-----构建子树形结构
+     *
+     * @param pNode 根节点（顶级节点）
+     * @return 整棵树
+     */
+    public TreeNode buildChildTree(TreeNode pNode) {
+        List<TreeNode> childTree = new ArrayList<TreeNode>();
+        // nodeList：所有节点集合（所有数据）
+        for (TreeNode treeNode : nodeList) {
+            // 判断当前节点的父节点ID是否等于根节点的ID，即当前节点是否为其下的子节点
+            if (treeNode.getParentSorts().contains(pNode.getSort())) {
+                // 再递归进行判断当前节点的情况，调用自身方法
+                childTree.add(buildChildTree(treeNode));
+            }
+        }
+        // for循环结束，即节点下没有任何节点，树形构建结束，设置树结果
+        pNode.setChildren(childTree);
+        return pNode;
+    }
+
+
+}

PAS/src/main/java/cn/cslg/pas/common/TreeNode.java

@@ -0,0 +1,41 @@
+package cn.cslg.pas.common;
+
+import lombok.Data;
+import lombok.experimental.Accessors;
+
+import java.util.List;
+
+/**
+ * 树结构类
+ *
+ * @author chenyu
+ * @date 2023/8/31
+ */
+@Accessors(chain = true)
+@Data
+public class TreeNode {
+    /**
+     * 节点ID（权要排序号）
+     */
+    private Integer sort;
+    /**
+     * 父节点ID：顶级节点为-1（父级权要排序号）
+     */
+    private List<Integer> parentSorts;
+    /**
+     * 节点名称（权要内容）
+     */
+    private String content;
+    /**
+     * 子节点（当前权要的所有子级权要）
+     */
+    private List<TreeNode> children;
+
+    public TreeNode(Integer sort, List<Integer> parentSorts, String content) {
+        this.sort = sort;
+        this.parentSorts = parentSorts;
+        this.content = content;
+    }
+
+
+}

PAS/src/main/java/cn/cslg/pas/controller/PatentRightController.java

@@ -0,0 +1,40 @@
+package cn.cslg.pas.controller;
+
+import cn.cslg.pas.common.TreeNode;
+import cn.cslg.pas.common.core.base.Constants;
+import cn.cslg.pas.common.utils.Response;
+import cn.cslg.pas.service.PatentRightService;
+import io.swagger.v3.oas.annotations.Operation;
+import io.swagger.v3.oas.annotations.tags.Tag;
+import lombok.RequiredArgsConstructor;
+import lombok.extern.slf4j.Slf4j;
+import org.springframework.web.bind.annotation.GetMapping;
+import org.springframework.web.bind.annotation.RequestMapping;
+import org.springframework.web.bind.annotation.RestController;
+
+import java.util.List;
+
+/**
+ * 权利要求控制层
+ *
+ * @author chenyu
+ * @date 2023/8/31
+ */
+@Tag(name = "权利要求")
+@Slf4j
+@RequiredArgsConstructor
+@RestController
+@RequestMapping(Constants.API_VERSION_V2 + "/patentRight")
+public class PatentRightController {
+    private final PatentRightService patentRightService;
+
+    @Operation(summary = "查询权利要求树")
+    @GetMapping("/queryPatentRightTree")
+    public Response queryPatentRightTree(Integer patentId) {
+        log.info("开始处理【查询权要树】的请求，请求参数为：patentId={}", patentId);
+        List<TreeNode> treeNodes = patentRightService.queryPatentRightTree(patentId);
+        return Response.ok(treeNodes);
+    }
+
+
+}

PAS/src/main/java/cn/cslg/pas/service/PatentRightService.java

@@ -1,15 +1,21 @@
 package cn.cslg.pas.service;
 
+import cn.cslg.pas.common.PatentRightContent;
+import cn.cslg.pas.common.TreeBuild;
+import cn.cslg.pas.common.TreeNode;
 import cn.cslg.pas.common.model.params.PatentRightParams;
 import cn.cslg.pas.common.utils.StringUtils;
+import cn.cslg.pas.common.utils.ThrowException;
 import cn.cslg.pas.domain.Authority;
 import cn.cslg.pas.domain.Patent;
 import cn.cslg.pas.domain.PatentRight;
 import cn.cslg.pas.mapper.PatentRightMapper;
+import cn.cslg.pas.service.patentRightSplit.*;
 import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
 import com.baomidou.mybatisplus.core.toolkit.Wrappers;
 import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
 import lombok.RequiredArgsConstructor;
+import lombok.extern.slf4j.Slf4j;
 import org.springframework.context.annotation.Lazy;
 import org.springframework.stereotype.Service;
 
@@ -24,10 +30,15 @@ import java.util.stream.Collectors;
  * @description 针对表【os_patent_right(专利权利要求)】的数据库操作Service
  * @createDate 2022-04-16 10:09:24
  */
+@Slf4j
 @Service
 @RequiredArgsConstructor(onConstructor_ = {@Lazy})
 public class PatentRightService extends ServiceImpl<PatentRightMapper, PatentRight> {
     private final PatentService patentService;
+    private final PatentRightSplitCNService patentRightSplitCNService;
+    private final PatentRightSplitENService patentRightSplitENService;
+//    private final PatentRightSplitJPService patentRightSplitJPService;
+//    private final PatentRightSplitKRService patentRightSplitKRService;
 
     public List<PatentRight> getPatentRightByPatentNo(String patentNo) {
         Patent patent = patentService.getByPatentNo(patentNo);
@@ -469,6 +480,81 @@ public class PatentRightService extends ServiceImpl<PatentRightMapper, PatentRig
 
     }
 
+    /**
+     * 查询权要树
+     *
+     * @param patentId 专利id
+     * @return 返回权要树集合
+     */
+    public List<TreeNode> queryPatentRightTree(Integer patentId) {
+        log.info("开始处理【查询权要树】的业务，业务参数为：patentId={}", patentId);
+
+        //根据专利id查询出专利
+        Patent patent = patentService.getById(patentId);
+
+        //判断若专利不存在，则返回错误提示"专利已不存在，请尝试刷新页面"
+        if (patent == null) {
+            ThrowException.throwXiaoShiException("专利已不存在，请尝试刷新页面");
+        }
+
+        //根据专利id查询出权要
+        List<PatentRight> patentRights = this.list(new LambdaQueryWrapper<PatentRight>().eq(PatentRight::getPatentId, patentId));
+
+        //装载权要原文
+        PatentRightParams params = new PatentRightParams();
+        //对获得的权利要求集合，判断集合元素个数若为1则为原文文本；若大于1则为已经拆分了的多个权要文本，此时就将其合并回原文文本
+        if (patentRights.size() == 1) {
+            params.setContent(patentRights.get(0).getContent());
+        } else if (patentRights.size() > 1) {
+            StringBuilder contentBuilder = new StringBuilder();
+            patentRights.forEach(patentRight -> {
+                contentBuilder.append(patentRight.getContent()).append("\n");
+            });
+            params.setContent(contentBuilder + "");
+        }
+
+        //调用拆分权要工厂类方法，返回对应该国家专利的拆分权要方法的对象
+        PatentRightSplitService obj = getPatentRightSplitServiceObj(patent.getPatentNo());
+        //对象调用拆分权要方法，返回处理过的（经过拆分、理出主附权要、理出层级关系的）权要集合
+        List<PatentRightContent> patentRightContents = obj.formatPatentRight(params);
+
+        List<TreeNode> treeNodeList = new ArrayList<>();
+
+        //判断若处理后的权要集合只有1个元素，则表示本次权要处理失败，则直接返回整个权要
+        if (patentRightContents.size() == 1) {
+            ArrayList<Integer> parentSorts = new ArrayList<>();
+            parentSorts.add(-1);
+            treeNodeList.add(new TreeNode(0, parentSorts, patentRightContents.get(0).getContent()).setChildren(new ArrayList<TreeNode>()));
+            return treeNodeList;
+        }
+
+        //开始进行权要树装载
+        for (PatentRightContent patentRightContent : patentRightContents) {
+            treeNodeList.add(new TreeNode(patentRightContent.getSort(), patentRightContent.getParentSorts(), patentRightContent.getContent()));
+        }
+        TreeBuild treeBuild = new TreeBuild(treeNodeList);
+        treeNodeList = treeBuild.buildTree();
+        return treeNodeList;
+
+    }
+
+
+    public PatentRightSplitService getPatentRightSplitServiceObj(String patentNo) {
+        String country = patentNo.substring(0, 2);
+        switch (country) {
+            case "CN":
+                return patentRightSplitCNService;  //拆分中国专利
+//            case "JP":
+//                return patentRightSplitJPService;  //拆分日本专利
+//            case "KR":
+//                return patentRightSplitKRService;  //拆分韩国专利
+            default:
+                return patentRightSplitENService;  //拆分英文专利
+
+        }
+
+    }
+
 
 }
 

PAS/src/main/java/cn/cslg/pas/service/patentRightSplit/PatentRightSplitCNService.java

@@ -1,7 +1,7 @@
 package cn.cslg.pas.service.patentRightSplit;
 
+import cn.cslg.pas.common.PatentRightContent;
 import cn.cslg.pas.common.model.params.PatentRightParams;
-import cn.cslg.pas.domain.PatentRight;
 import org.springframework.stereotype.Service;
 
 import java.util.ArrayList;
@@ -19,10 +19,10 @@ import java.util.regex.Pattern;
 public class PatentRightSplitCNService implements PatentRightSplitService {
 
     @Override
-    public List<PatentRight> formatPatentRight(PatentRightParams params) {
+    public List<PatentRightContent> formatPatentRight(PatentRightParams params) {
         try {
             //创建一个权要集合，用于返回结果
-            ArrayList<PatentRight> patentRights = new ArrayList<>();
+            ArrayList<PatentRightContent> patentRightContents = new ArrayList<>();
             //原文
             String content = params.getContent();
 
@@ -53,20 +53,19 @@ public class PatentRightSplitCNService implements PatentRightSplitService {
             String[] strs = content.split("\n");
 
 
-            //第2步：理出每个权要的类型（type为 1主权要还是 0附属权要）、理出权要之间的层级关系（每个权要的父级权要序号parentSort） ↓
+            //第2步：理出权要的类型（type为 1主权要还是 0附属权要）、权要之间的层级关系（每个权要的父级权要序号parentSort） ↓
             String regex1 = "权利要求[0-9]+";
             String regex2 = "权利要求[0-9]+[至或～-]+[0-9]+";
             for (int i = 0; i < strs.length; i++) {
                 //创建权要对象装载当前权要
-                PatentRight patentRight = new PatentRight()
-                        .setPatentId(params.getPatentId())
+                PatentRightContent patentRightContent = new PatentRightContent()
                         .setContent(strs[i])
                         .setSort(i);
 
                 //判断若该权要有逗号（即超过一句话）并且它第一句话中有"权利要求"4个字 或者 该权要没有逗号（即只有一句话），并且它有"权利要求"4个字，则该权要类型为附属权要
                 if ((strs[i].contains("，") && strs[i].substring(0, strs[i].indexOf("，")).contains("权利要求")) || (!strs[i].contains("，") && strs[i].contains("权利要求"))) {
-                    //则该权要类型为附属权要
-                    patentRight.setType(0);
+                    //则该权要为附权要
+                    patentRightContent.setType(0);
 
                     Matcher matcher1 = Pattern.compile(regex1).matcher(strs[i]);
                     Matcher matcher2 = Pattern.compile(regex2).matcher(strs[i]);
@@ -83,49 +82,46 @@ public class PatentRightSplitCNService implements PatentRightSplitService {
                             parentNumStrs = parentNum.split("或");
                         }
 
-                        int[] parentSorts = new int[parentNumStrs.length];  //[1, 3]
-                        for (int i1 = 0; i1 < parentSorts.length; i1++) {
-                            parentSorts[i1] = Integer.parseInt(parentNumStrs[i1]) - 1;
+                        ArrayList<Integer> parentSorts = new ArrayList<>();  //{1, 3}
+                        for (int i1 = 0; i1 < parentNumStrs.length; i1++) {
+                            parentSorts.add(Integer.parseInt(parentNumStrs[i1]) - 1);  //{1, 3}
                         }
 
                         if (parentNum.contains("或")) {
-                            StringBuilder builder = new StringBuilder();
-                            for (int parentSort : parentSorts) {
-                                builder.append(parentSort).append(",");
-                            }
-                            patentRight.setParentSort(builder.substring(0, builder.lastIndexOf(",")));
+                            patentRightContent.setParentSorts(parentSorts);
                         } else {
-                            StringBuilder builder = new StringBuilder();
-                            for (int j = parentSorts[0]; j <= parentSorts[parentSorts.length - 1]; j++) {
-                                if ((builder + "").equals("")) {
-                                    builder.append(j);
-                                } else {
-                                    builder.append(",").append(j);
-                                }
+                            ArrayList<Integer> parentSorts2 = new ArrayList<>();
+                            for (int i1 = parentSorts.get(0); i1 < parentSorts.get(parentSorts.size() - 1); i1++) {
+                                parentSorts2.add(i1);
                             }
-                            patentRight.setParentSort(builder + "");
+                            patentRightContent.setParentSorts(parentSorts2);
                         }
 
                     } else if (matcher1.find()) {
                         String parentNum = matcher1.group().substring(matcher1.group().indexOf("权利要求") + 4);
-                        patentRight.setParentSort((Integer.parseInt(parentNum) - 1) + "");
+                        int parentSort = Integer.parseInt(parentNum) - 1;
+                        ArrayList<Integer> parentSorts = new ArrayList<>();
+                        parentSorts.add(parentSort);
+                        patentRightContent.setParentSorts(parentSorts);
                     }
                 } else {
                     //否则该权要为主权要
-                    patentRight
+                    ArrayList<Integer> parentSorts = new ArrayList<>();
+                    parentSorts.add(-1);
+                    patentRightContent
                             .setType(1)
-                            .setParentSort("-1");
+                            .setParentSorts(parentSorts);
                 }
 
-                patentRights.add(patentRight);
+                patentRightContents.add(patentRightContent);
             }
 
-            return patentRights;
+            return patentRightContents;
         } catch (Exception e) {
             e.printStackTrace();
-            ArrayList<PatentRight> patentRights = new ArrayList<>();
-            patentRights.add(new PatentRight().setContent(params.getContent()));
-            return patentRights;
+            ArrayList<PatentRightContent> patentRightContents = new ArrayList<>();
+            patentRightContents.add(new PatentRightContent().setContent(params.getContent()));
+            return patentRightContents;
         }
 
     }

PAS/src/main/java/cn/cslg/pas/service/patentRightSplit/PatentRightSplitENService.java

@@ -1,11 +1,11 @@
 package cn.cslg.pas.service.patentRightSplit;
 
+import cn.cslg.pas.common.PatentRightContent;
 import cn.cslg.pas.common.model.params.PatentRightParams;
 import cn.cslg.pas.domain.PatentRight;
 import org.springframework.stereotype.Service;
 
 import java.util.ArrayList;
-import java.util.Arrays;
 import java.util.List;
 import java.util.regex.Matcher;
 import java.util.regex.Pattern;
@@ -20,10 +20,10 @@ import java.util.regex.Pattern;
 public class PatentRightSplitENService implements PatentRightSplitService {
 
     @Override
-    public List<PatentRight> formatPatentRight(PatentRightParams params) {
+    public List<PatentRightContent> formatPatentRight(PatentRightParams params) {
         try {
             //创建一个权要集合，用于返回结果
-            ArrayList<PatentRight> patentRights = new ArrayList<>();
+            ArrayList<PatentRightContent> patentRightContents = new ArrayList<>();
             //取出原文
             String content = params.getContent();
 
@@ -55,15 +55,16 @@ public class PatentRightSplitENService implements PatentRightSplitService {
             String regex3 = "any preceding claim";
             for (int i = 0; i < strs.length; i++) {
                 //创建权要对象装载当前权要
-                PatentRight patentRight = new PatentRight()
-                        .setPatentId(params.getPatentId())
+                PatentRightContent patentRightContent = new PatentRightContent()
                         .setContent(strs[i])
                         .setSort(i);
+                //创建父级排序号集合，装载父级序号
+                ArrayList<Integer> parentSorts = new ArrayList<>();
 
                 //判断若该权要有逗号（即超过一句话）并且它第一句话中有"权利要求"4个字 或者 该权要没有逗号（即只有一句话），并且它有"权利要求"4个字，则该权要类型为附属权要
                 if ((strs[i].contains("，") && strs[i].substring(0, strs[i].indexOf("，")).contains("claim")) || (!strs[i].contains("，") && strs[i].contains("claim"))) {
                     //则该权要类型为附属权要
-                    patentRight.setType(0);
+                    patentRightContent.setType(0);
 
                     Matcher matcher1 = Pattern.compile(regex1).matcher(strs[i]);
                     Matcher matcher2 = Pattern.compile(regex2).matcher(strs[i]);
@@ -75,43 +76,40 @@ public class PatentRightSplitENService implements PatentRightSplitService {
                             parentNumStrs = parentNum.split(" or ");  //[2, 3]
                         }
 
-                        int[] parentSorts = new int[parentNumStrs.length];  //[1, 2]
-                        for (int i1 = 0; i1 < parentSorts.length; i1++) {
-                            parentSorts[i1] = Integer.parseInt(parentNumStrs[i1]) - 1;
+                        for (String parentNumStr : parentNumStrs) {
+                            parentSorts.add(Integer.parseInt(parentNumStr) - 1);
                         }
 
-                        StringBuilder builder = new StringBuilder();
-                        for (int parentSort : parentSorts) {
-                            builder.append(parentSort).append(",");
-                        }
-                        patentRight.setParentSort(builder.substring(0, builder.lastIndexOf(",")));
+                        patentRightContent.setParentSorts(parentSorts);
 
                     } else if (matcher1.find()) {
                         String parentNum = matcher1.group().substring(matcher1.group().indexOf("claim") + 6);
-                        patentRight.setParentSort((Integer.parseInt(parentNum) - 1) + "");
+                        int parentSort = Integer.parseInt(parentNum) - 1;
+                        parentSorts.add(parentSort);
+                        patentRightContent.setParentSorts(parentSorts);
                     } else if (matcher3.find()) {
-                        StringBuilder builder = new StringBuilder();
                         for (int sort = 0; sort < i; sort++) {
-                            builder.append(sort).append(",");
+                            parentSorts.add(sort);
                         }
-                        patentRight.setParentSort(builder.substring(0, builder.lastIndexOf(",")));
+                        patentRightContent.setParentSorts(parentSorts);
                     }
                 } else {
                     //否则该权要为主权要
-                    patentRight
+                    parentSorts.add(-1);
+                    patentRightContent
                             .setType(1)
-                            .setParentSort("-1");
+                            .setParentSorts(parentSorts);
                 }
 
-                patentRights.add(patentRight);
+                patentRightContents.add(patentRightContent);
             }
 
-            return patentRights;
+            return patentRightContents;
         } catch (Exception e) {
             e.printStackTrace();
-            ArrayList<PatentRight> patentRights = new ArrayList<>();
-            patentRights.add(new PatentRight().setContent(params.getContent()));
-            return patentRights;
+            ArrayList<PatentRightContent> patentRightContents = new ArrayList<>();
+            patentRightContents.add(new PatentRightContent().setContent(params.getContent()));
+            return patentRightContents;
         }
 
     }

PAS/src/main/java/cn/cslg/pas/service/patentRightSplit/PatentRightSplitJPService.java

@@ -0,0 +1,132 @@
+//package cn.cslg.pas.service.patentRightSplit;
+//
+//import cn.cslg.pas.common.model.params.PatentRightParams;
+//import cn.cslg.pas.domain.PatentRight;
+//import org.springframework.stereotype.Service;
+//
+//import java.util.ArrayList;
+//import java.util.List;
+//import java.util.regex.Matcher;
+//import java.util.regex.Pattern;
+//
+///**
+// * 拆分权要类（日本专利JP）
+// *
+// * @author chenyu
+// * @date 2023/8/30
+// */
+//@Service
+//public class PatentRightSplitJPService implements PatentRightSplitService {
+//
+//    @Override
+//    public List<PatentRight> formatPatentRight(PatentRightParams params) {
+//        try {
+//            //创建一个权要集合，用于返回结果
+//            ArrayList<PatentRight> patentRights = new ArrayList<>();
+//            //原文
+//            String content = params.getContent();
+//
+//            //将原文从"1"截取到末尾（为了去除首行"声称的是:\n"）
+////            if (!content.equals("") && content.contains("声称的是") && content.contains("1")) {
+////                content = content.substring(content.indexOf("1"));
+////            }
+//
+//            //第1步：拆分权要原文 ↓
+//            //将原文和译文的所有换行符 "\r\n"和"\n" 替换成特殊符号 "##@@&&"，这样可以使得全文连在一起，其次再根据特殊符号##@@&&拆分权要
+//            content = content.replace("\r\n", "##@@&&").replace("\n", "##@@&&");
+//
+//            //若原文没有换行符，则全文按照句号"。"拆分
+//            if (!content.contains("##@@&&")) {
+//                content = content.replace("。", "。\n");
+//            } else {
+//                //定义正则表达式
+//                String regex = "##@@&&[0-9]+";
+//                Matcher matcher = Pattern.compile(regex).matcher(content);
+//                while (matcher.find()) {
+//                    String macherGroup = matcher.group();
+//                    content = content.replaceFirst(macherGroup, "\n" + macherGroup.substring(macherGroup.indexOf("##@@&&") + 6));
+//                }
+//                //去除所有特殊符号"##@@&&"
+//                content = content.replace("##@@&&", "");
+//            }
+//            //最后按照换行符"\n"将权要拆成多个
+//            String[] strs = content.split("\n");
+//
+//
+//            //第2步：理出每个权要的类型（type为 1主权要还是 0附属权要）、理出权要之间的层级关系（每个权要的父级权要序号parentSort） ↓
+//            String regex1 = "权利要求[0-9]+";
+//            String regex2 = "权利要求[0-9]+[至或～-]+[0-9]+";
+//            for (int i = 0; i < strs.length; i++) {
+//                //创建权要对象装载当前权要
+//                PatentRight patentRight = new PatentRight()
+//                        .setContent(strs[i])
+//                        .setSort(i);
+//
+//                //判断若该权要有逗号（即超过一句话）并且它第一句话中有"权利要求"4个字 或者 该权要没有逗号（即只有一句话），并且它有"权利要求"4个字，则该权要类型为附属权要
+//                if ((strs[i].contains("，") && strs[i].substring(0, strs[i].indexOf("，")).contains("权利要求")) || (!strs[i].contains("，") && strs[i].contains("权利要求"))) {
+//                    //则该权要类型为附属权要
+//                    patentRight.setType(0);
+//
+//                    Matcher matcher1 = Pattern.compile(regex1).matcher(strs[i]);
+//                    Matcher matcher2 = Pattern.compile(regex2).matcher(strs[i]);
+//                    if (matcher2.find()) {  //"权利要求2~4"
+//                        String parentNum = matcher2.group().substring(matcher2.group().indexOf("权利要求") + 4);  //"2~4"
+//                        String[] parentNumStrs = new String[0];
+//                        if (parentNum.contains("～")) {
+//                            parentNumStrs = parentNum.split("～");  //[2, 4]
+//                        } else if (parentNum.contains("-")) {
+//                            parentNumStrs = parentNum.split("-");
+//                        } else if (parentNum.contains("至")) {
+//                            parentNumStrs = parentNum.split("至");
+//                        } else if (parentNum.contains("或")) {
+//                            parentNumStrs = parentNum.split("或");
+//                        }
+//
+//                        int[] parentSorts = new int[parentNumStrs.length];  //[1, 3]
+//                        for (int i1 = 0; i1 < parentSorts.length; i1++) {
+//                            parentSorts[i1] = Integer.parseInt(parentNumStrs[i1]) - 1;
+//                        }
+//
+//                        if (parentNum.contains("或")) {
+//                            StringBuilder builder = new StringBuilder();
+//                            for (int parentSort : parentSorts) {
+//                                builder.append(parentSort).append(",");
+//                            }
+//                            patentRight.setParentSort(builder.substring(0, builder.lastIndexOf(",")));
+//                        } else {
+//                            StringBuilder builder = new StringBuilder();
+//                            for (int j = parentSorts[0]; j <= parentSorts[parentSorts.length - 1]; j++) {
+//                                if ((builder + "").equals("")) {
+//                                    builder.append(j);
+//                                } else {
+//                                    builder.append(",").append(j);
+//                                }
+//                            }
+//                            patentRight.setParentSort(builder + "");
+//                        }
+//
+//                    } else if (matcher1.find()) {
+//                        String parentNum = matcher1.group().substring(matcher1.group().indexOf("权利要求") + 4);
+//                        patentRight.setParentSort((Integer.parseInt(parentNum) - 1) + "");
+//                    }
+//                } else {
+//                    //否则该权要为主权要
+//                    patentRight
+//                            .setType(1)
+//                            .setParentSort("-1");
+//                }
+//
+//                patentRights.add(patentRight);
+//            }
+//
+//            return patentRights;
+//        } catch (Exception e) {
+//            e.printStackTrace();
+//            ArrayList<PatentRight> patentRights = new ArrayList<>();
+//            patentRights.add(new PatentRight().setContent(params.getContent()));
+//            return patentRights;
+//        }
+//
+//    }
+//
+//}

PAS/src/main/java/cn/cslg/pas/service/patentRightSplit/PatentRightSplitKRService.java

@@ -0,0 +1,132 @@
+//package cn.cslg.pas.service.patentRightSplit;
+//
+//import cn.cslg.pas.common.model.params.PatentRightParams;
+//import cn.cslg.pas.domain.PatentRight;
+//import org.springframework.stereotype.Service;
+//
+//import java.util.ArrayList;
+//import java.util.List;
+//import java.util.regex.Matcher;
+//import java.util.regex.Pattern;
+//
+///**
+// * 拆分权要类（韩国专利KR）
+// *
+// * @author chenyu
+// * @date 2023/8/30
+// */
+//@Service
+//public class PatentRightSplitKRService implements PatentRightSplitService {
+//
+//    @Override
+//    public List<PatentRight> formatPatentRight(PatentRightParams params) {
+//        try {
+//            //创建一个权要集合，用于返回结果
+//            ArrayList<PatentRight> patentRights = new ArrayList<>();
+//            //原文
+//            String content = params.getContent();
+//
+//            //将原文从"1"截取到末尾（为了去除首行"声称的是:\n"）
+////            if (!content.equals("") && content.contains("声称的是") && content.contains("1")) {
+////                content = content.substring(content.indexOf("1"));
+////            }
+//
+//            //第1步：拆分权要原文 ↓
+//            //将原文和译文的所有换行符 "\r\n"和"\n" 替换成特殊符号 "##@@&&"，这样可以使得全文连在一起，其次再根据特殊符号##@@&&拆分权要
+//            content = content.replace("\r\n", "##@@&&").replace("\n", "##@@&&");
+//
+//            //若原文没有换行符，则全文按照句号"。"拆分
+//            if (!content.contains("##@@&&")) {
+//                content = content.replace("。", "。\n");
+//            } else {
+//                //定义正则表达式
+//                String regex = "##@@&&[0-9]+";
+//                Matcher matcher = Pattern.compile(regex).matcher(content);
+//                while (matcher.find()) {
+//                    String macherGroup = matcher.group();
+//                    content = content.replaceFirst(macherGroup, "\n" + macherGroup.substring(macherGroup.indexOf("##@@&&") + 6));
+//                }
+//                //去除所有特殊符号"##@@&&"
+//                content = content.replace("##@@&&", "");
+//            }
+//            //最后按照换行符"\n"将权要拆成多个
+//            String[] strs = content.split("\n");
+//
+//
+//            //第2步：理出每个权要的类型（type为 1主权要还是 0附属权要）、理出权要之间的层级关系（每个权要的父级权要序号parentSort） ↓
+//            String regex1 = "权利要求[0-9]+";
+//            String regex2 = "权利要求[0-9]+[至或～-]+[0-9]+";
+//            for (int i = 0; i < strs.length; i++) {
+//                //创建权要对象装载当前权要
+//                PatentRight patentRight = new PatentRight()
+//                        .setContent(strs[i])
+//                        .setSort(i);
+//
+//                //判断若该权要有逗号（即超过一句话）并且它第一句话中有"权利要求"4个字 或者 该权要没有逗号（即只有一句话），并且它有"权利要求"4个字，则该权要类型为附属权要
+//                if ((strs[i].contains("，") && strs[i].substring(0, strs[i].indexOf("，")).contains("权利要求")) || (!strs[i].contains("，") && strs[i].contains("权利要求"))) {
+//                    //则该权要类型为附属权要
+//                    patentRight.setType(0);
+//
+//                    Matcher matcher1 = Pattern.compile(regex1).matcher(strs[i]);
+//                    Matcher matcher2 = Pattern.compile(regex2).matcher(strs[i]);
+//                    if (matcher2.find()) {  //"权利要求2~4"
+//                        String parentNum = matcher2.group().substring(matcher2.group().indexOf("权利要求") + 4);  //"2~4"
+//                        String[] parentNumStrs = new String[0];
+//                        if (parentNum.contains("～")) {
+//                            parentNumStrs = parentNum.split("～");  //[2, 4]
+//                        } else if (parentNum.contains("-")) {
+//                            parentNumStrs = parentNum.split("-");
+//                        } else if (parentNum.contains("至")) {
+//                            parentNumStrs = parentNum.split("至");
+//                        } else if (parentNum.contains("或")) {
+//                            parentNumStrs = parentNum.split("或");
+//                        }
+//
+//                        int[] parentSorts = new int[parentNumStrs.length];  //[1, 3]
+//                        for (int i1 = 0; i1 < parentSorts.length; i1++) {
+//                            parentSorts[i1] = Integer.parseInt(parentNumStrs[i1]) - 1;
+//                        }
+//
+//                        if (parentNum.contains("或")) {
+//                            StringBuilder builder = new StringBuilder();
+//                            for (int parentSort : parentSorts) {
+//                                builder.append(parentSort).append(",");
+//                            }
+//                            patentRight.setParentSort(builder.substring(0, builder.lastIndexOf(",")));
+//                        } else {
+//                            StringBuilder builder = new StringBuilder();
+//                            for (int j = parentSorts[0]; j <= parentSorts[parentSorts.length - 1]; j++) {
+//                                if ((builder + "").equals("")) {
+//                                    builder.append(j);
+//                                } else {
+//                                    builder.append(",").append(j);
+//                                }
+//                            }
+//                            patentRight.setParentSort(builder + "");
+//                        }
+//
+//                    } else if (matcher1.find()) {
+//                        String parentNum = matcher1.group().substring(matcher1.group().indexOf("权利要求") + 4);
+//                        patentRight.setParentSort((Integer.parseInt(parentNum) - 1) + "");
+//                    }
+//                } else {
+//                    //否则该权要为主权要
+//                    patentRight
+//                            .setType(1)
+//                            .setParentSort("-1");
+//                }
+//
+//                patentRights.add(patentRight);
+//            }
+//
+//            return patentRights;
+//        } catch (Exception e) {
+//            e.printStackTrace();
+//            ArrayList<PatentRight> patentRights = new ArrayList<>();
+//            patentRights.add(new PatentRight().setContent(params.getContent()));
+//            return patentRights;
+//        }
+//
+//    }
+//
+//}

PAS/src/main/java/cn/cslg/pas/service/patentRightSplit/PatentRightSplitService.java

@@ -1,7 +1,7 @@
 package cn.cslg.pas.service.patentRightSplit;
 
+import cn.cslg.pas.common.PatentRightContent;
 import cn.cslg.pas.common.model.params.PatentRightParams;
-import cn.cslg.pas.domain.PatentRight;
 
 import java.util.List;
 
@@ -18,6 +18,6 @@ public interface PatentRightSplitService {
      * @param params 装载权要对象
      * @return 返回已拆分、理出主附权要、层级关系的多个权要
      */
-    List<PatentRight> formatPatentRight(PatentRightParams params);
+    List<PatentRightContent> formatPatentRight(PatentRightParams params);
 
 }

PAS/src/test/java/cn/cslg/pas/service/PatentRightServiceTests.java

@@ -0,0 +1,27 @@
+package cn.cslg.pas.service;
+
+import cn.cslg.pas.common.TreeNode;
+import org.junit.jupiter.api.Test;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.boot.test.context.SpringBootTest;
+
+import java.util.List;
+
+/**
+ * @author chenyu
+ * @date 2023/8/31
+ */
+@SpringBootTest
+public class PatentRightServiceTests {
+    @Autowired
+    private PatentRightService patentRightService;
+
+    /**
+     * 查询权利要求树
+     */
+    @Test
+    void queryPatentRightTree() {
+        List<TreeNode> treeNodes = patentRightService.queryPatentRightTree(184872);
+    }
+
+}

PAS/src/test/java/cn/cslg/pas/service/PatentRightSplitCNServiceTests.java

@@ -1,7 +1,7 @@
 package cn.cslg.pas.service;
 
+import cn.cslg.pas.common.PatentRightContent;
 import cn.cslg.pas.common.model.params.PatentRightParams;
-import cn.cslg.pas.domain.PatentRight;
 import cn.cslg.pas.service.patentRightSplit.PatentRightSplitCNService;
 import org.junit.jupiter.api.Test;
 import org.springframework.beans.factory.annotation.Autowired;
@@ -44,7 +44,7 @@ public class PatentRightSplitCNServiceTests {
                 "8.一种汇流电机总成，包括齿轮箱以及分别与齿轮箱连接的多个电机，其特征在于：还包括权利要求1-7中任一项所述的用于多电机的自适应冷却分配系统；还包括与多个电机同时连接的固定板，且相邻所述电机之间连接有固定杆；所述电机包括电机壳体，所述电机壳体外侧壁设置有用于与固定杆或者固定板连接的固定环。\n" +
                 "\"\n");
 
-        List<PatentRight> patentRights = patentRightSplitCNService.formatPatentRight(params);
+        List<PatentRightContent> patentRightContents = patentRightSplitCNService.formatPatentRight(params);
 
 
     }