拆分特征

src/main/java/cn/cslg/pas/common/config/WebSocketConfig.java

@@ -6,8 +6,8 @@ import org.springframework.web.socket.server.standard.ServerEndpointExporter;
 
 @Configuration
 public class WebSocketConfig {
-    @Bean
-    public ServerEndpointExporter serverEndpointExporter() {
-        return new ServerEndpointExporter();
-    }
+//    @Bean
+//    public ServerEndpointExporter serverEndpointExporter() {
+//        return new ServerEndpointExporter();
+//    }
 }

src/main/java/cn/cslg/pas/common/dto/UploadPatentWebDTO.java

@@ -5,9 +5,11 @@ import cn.cslg.pas.common.vo.UploadParamsVO;
 import cn.cslg.pas.domain.es.Patent;
 import com.baomidou.mybatisplus.annotation.DbType;
 import lombok.Data;
+import lombok.Synchronized;
 import org.apache.poi.ss.usermodel.PictureData;
 
 @Data
+
 public class UploadPatentWebDTO {
     private StarPatentVO starPatentVO;
     private Patent patent;

src/main/java/cn/cslg/pas/common/utils/PatentRightUtils.java

@@ -0,0 +1,327 @@
+package cn.cslg.pas.common.utils;
+
+
+
+
+import cn.cslg.pas.common.vo.PatentRightParams;
+import cn.cslg.pas.common.vo.RePatentClaim;
+import org.springframework.stereotype.Component;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.List;
+import java.util.regex.Matcher;
+import java.util.regex.Pattern;
+
+/**
+ * 拆分权要工具类
+ *
+ * @Author chenyu
+ * @Date 2023/4/25
+ */
+@Component
+public class PatentRightUtils {
+
+    public static List<RePatentClaim> formatPatentRight(PatentRightParams params) {
+        try {
+            //国家
+            String country = params.getPatentNo().substring(0, 2);
+            //原文
+            String content = params.getContent();
+            //译文
+            String contentOut = params.getContentOut();
+
+            //创建一个权要集合
+            ArrayList<RePatentClaim> patentRights = new ArrayList<>();
+
+            //若原文为null或空串，则直接结束并返回空集合；若译文为null，则置为空串
+            if (content == null || content.equals("")) {
+                return patentRights;
+            }
+
+            if (contentOut == null) {
+                contentOut = "";
+            }
+
+            //将原文和译文的所有换行符 "\r\n"或是"\n" 替换成 "@"，这样首先可以使得全文连在一起，其次再根据特殊符号@拆分权要
+            if (content.contains("\r\n")) {
+                content = content.replaceAll("\r\n", "@");
+            }
+            if (content.contains("\n")) {
+                content = content.replaceAll("\n", "@");
+            }
+
+            if (contentOut.contains("\r\n")) {
+                contentOut = contentOut.replaceAll("\r\n", "@");
+            }
+            if (contentOut.contains("\n")) {
+                contentOut = contentOut.replaceAll("\n", "@");
+            }
+
+            //去掉译文的所有空格
+            contentOut = contentOut.replaceAll(" +", "");
+
+            //中日韩权要↓
+            if (country.equals("CN") || country.equals("JP") || country.equals("KR") || content.contains("权利要求")) {
+                String regex;
+                if (content.contains("@2")) {
+                    regex = "@[0-9]+";
+                } else if (content.contains("@[00")) {
+                    regex = "@\\[[0-9]+]";
+                } else if (content.contains("@請求項")) {
+                    regex = "@【請求項[0-9]+】";
+                } else if (content.contains("@청구항")) {
+                    regex = "@청구항 [0-9]+";
+                } else {
+                    regex = "";
+                }
+                String[] strs;  //原文数组
+                String[] strsOut;  //译文数组
+                //若以上没有匹配到，则权要直接以句号 "。" 拆分
+                if (regex.equals("")) {
+                    content = content.replaceAll("@", "");
+                    contentOut = contentOut.replaceAll("@", "");
+                    strs = content.split("。");
+                    strsOut = contentOut.split("。");
+                    //若匹配到，则根据不同情形拆分
+                } else {
+                    Matcher matcher = Pattern.compile(regex).matcher(content);
+                    Matcher matcherOut = Pattern.compile(regex).matcher(contentOut);
+                    while (matcher.find()) {
+                        content = content.replaceFirst(matcher.group(), "\n" + matcher.group().substring(matcher.group().indexOf("@") + 1));
+                    }
+                    while (matcherOut.find()) {
+                        contentOut = contentOut.replaceFirst(matcherOut.group(), "\n" + matcherOut.group().substring(matcherOut.group().indexOf("@") + 1));
+                    }
+                    content = content.replaceAll("@", "");
+                    contentOut = contentOut.replaceAll("@", "");
+                    strs = content.split("\n");
+                    strsOut = contentOut.split("\n");
+                }
+                //定义父权要排序号
+                String regex1 = "权利要求[0-9]+";
+                String regex2 = "权利要求[0-9]+[至或～-]+[0-9]+";
+                for (int i = 0; i < strs.length; i++) {
+                    //之前：if (strs[i].contains("权利要求")) {
+                    //现在：if(该权要有逗号，并且它第一句话中有"权利要求"4个字 || 该权要没有逗号，并且它有"权利要求"4个字) {
+                    if ((strs[i].contains("，") && strs[i].substring(0, strs[i].indexOf("，")).contains("权利要求")) || (!strs[i].contains("，") && strs[i].contains("权利要求"))) {
+                        Matcher matcher1 = Pattern.compile(regex1).matcher(strs[i]);
+                        Matcher matcher2 = Pattern.compile(regex2).matcher(strs[i]);
+                        if (matcher2.find()) {
+                            String parentNum = matcher2.group().substring(matcher2.group().indexOf("求") + 1);
+                            String[] parentNums;
+                            if (parentNum.contains("～")) {
+                                parentNums = parentNum.split("～");
+                            } else if (parentNum.contains("-")) {
+                                parentNums = parentNum.split("-");
+                            } else if (parentNum.contains("至")) {
+                                parentNums = parentNum.split("至");
+                            } else if (parentNum.contains("或")) {
+                                parentNums = parentNum.split("或");
+                            } else {
+                                parentNums = new String[0];
+                            }
+                            StringBuilder builder = new StringBuilder();
+                            for (int j = Integer.parseInt(parentNums[0]) - 1; j < Integer.parseInt(parentNums[parentNums.length - 1]); j++) {
+                                if ((builder + "").equals("")) {
+                                    builder.append(j);
+                                } else {
+                                    builder.append(",").append(j);
+                                }
+                            }
+                            RePatentClaim patentRight = new RePatentClaim()
+                                    .setPatentId(params.getPatentId())
+                                    .setType(0)
+                                    .setContent(strs[i])
+                                    .setSort(i)
+                                    .setParentSort(builder + "");
+                            if (strsOut.length - 1 >= i) {
+                                //当翻译的长度大于原文权要的长度时，将剩下所有的译文给最后一条原文
+                                if (strsOut.length > strs.length && strs.length == (i + 1)) {
+                                    patentRight.setContentOut(String.join(" ", Arrays.copyOfRange(strsOut, i, strsOut.length)));
+                                } else {
+                                    patentRight.setContentOut(strsOut[i]);
+                                }
+                            }
+                            patentRights.add(patentRight);
+                        } else if (matcher1.find()) {
+                            String parentNum = matcher1.group().substring(matcher1.group().indexOf("求") + 1);
+                            RePatentClaim patentRight = new RePatentClaim()
+                                    .setPatentId(params.getPatentId())
+                                    .setType(0)
+                                    .setContent(strs[i])
+                                    .setSort(i)
+                                    .setParentSort((Integer.parseInt(parentNum) - 1) + "");
+                            if (strsOut.length - 1 >= i) {
+                                patentRight.setContentOut(strsOut[i]);
+                            }
+                            patentRights.add(patentRight);
+                        }
+
+                    } else {
+                        RePatentClaim patentRight = new RePatentClaim()
+                                .setPatentId(params.getPatentId())
+                                .setType(1)
+                                .setContent(strs[i])
+                                .setSort(i)
+                                .setParentSort("-1");
+                        if (strsOut.length - 1 >= i) {
+                            //当翻译的长度大于原文权要的长度时，将剩下所有的译文给最后一条原文
+                            if (strsOut.length > strs.length && strs.length == (i + 1)) {
+                                patentRight.setContentOut(String.join(" ", Arrays.copyOfRange(strsOut, i, strsOut.length)));
+                            } else {
+                                patentRight.setContentOut(strsOut[i]);
+                            }
+                        }
+                        patentRights.add(patentRight);
+                    }
+                }
+                //英文专利的权要拆分 ↓
+            } else {
+                if (!content.equals("") && content.contains("1")) {
+                    content = content.substring(content.indexOf("1"));
+                }
+                if (!contentOut.equals("") && contentOut.contains("1")) {
+                    contentOut = contentOut.substring(contentOut.indexOf("1"));
+                }
+
+                String regex;
+                if (content.contains("@2")) {
+                    regex = "@[0-9]+";
+                } else if (content.contains("[001]")) {
+                    regex = "\\[[0-9]+]";
+                } else {
+                    regex = "";
+                }
+
+                Matcher matcher = Pattern.compile(regex).matcher(content);
+                Matcher matcherOut = Pattern.compile(regex).matcher(contentOut);
+                while (matcher.find()) {
+                    content = content.replaceFirst(matcher.group(), "\n" + matcher.group().substring(matcher.group().indexOf("@") + 1));
+                }
+                while (matcherOut.find()) {
+                    contentOut = contentOut.replaceFirst(matcherOut.group(), "\n" + matcherOut.group().substring(matcherOut.group().indexOf("@") + 1));
+                }
+                content = content.replaceAll("@", "");
+                contentOut = contentOut.replaceAll("@", "");
+                String[] strs = content.split("\n");
+                String[] strsOut = contentOut.split("\n");
+
+                //定义父权要排序号
+                String regex1 = "claim [0-9]+";
+                String regex2 = "claims [0-9]+ or [0-9]+";
+                String regex3 = "any preceding claim";
+                for (int i = 0; i < strs.length; i++) {
+                    if (strs[i].contains("claim")) {
+                        Matcher matcher1 = Pattern.compile(regex1).matcher(strs[i]);
+                        Matcher matcher2 = Pattern.compile(regex2).matcher(strs[i]);
+                        Matcher matcher3 = Pattern.compile(regex3).matcher(strs[i]);
+                        if (matcher2.find()) {
+                            String parentNum = matcher2.group().substring(matcher2.group().indexOf("s") + 2);
+                            String[] parentNums;
+                            if (parentNum.contains(" or ")) {
+                                parentNums = parentNum.split(" or ");
+                            } else if (parentNum.contains(" - ")) {
+                                parentNums = parentNum.split(" - ");
+                            } else if (parentNum.contains(" to ")) {
+                                parentNums = parentNum.split(" to ");
+                            } else if (parentNum.contains("或")) {
+                                parentNums = parentNum.split("或");
+                            } else {
+                                parentNums = new String[0];
+                            }
+                            StringBuilder builder = new StringBuilder();
+                            for (int j = Integer.parseInt(parentNums[0]) - 1; j < Integer.parseInt(parentNums[parentNums.length - 1]); j++) {
+                                if ((builder + "").equals("")) {
+                                    builder.append(j);
+                                } else {
+                                    builder.append(",").append(j);
+                                }
+                            }
+                            RePatentClaim patentRight = new RePatentClaim()
+                                    .setPatentId(params.getPatentId())
+                                    .setType(0)
+                                    .setContent(strs[i])
+                                    .setSort(i)
+                                    .setParentSort(builder + "");
+                            if (strsOut.length - 1 >= i) {
+                                //当翻译的长度大于原文权要的长度时，将剩下所有的译文给最后一条原文
+                                if (strsOut.length > strs.length && strs.length == (i + 1)) {
+                                    patentRight.setContentOut(String.join(" ", Arrays.copyOfRange(strsOut, i, strsOut.length)));
+                                } else {
+                                    patentRight.setContentOut(strsOut[i]);
+                                }
+                            }
+                            patentRights.add(patentRight);
+                        } else if (matcher1.find()) {
+                            String parentNum = matcher1.group().substring(matcher1.group().indexOf("m") + 2);
+                            RePatentClaim patentRight = new RePatentClaim()
+                                    .setPatentId(params.getPatentId())
+                                    .setType(0)
+                                    .setContent(strs[i])
+                                    .setSort(i)
+                                    .setParentSort((Integer.parseInt(parentNum) - 1) + "");
+                            if (strsOut.length - 1 >= i) {
+                                //当翻译的长度大于原文权要的长度时，将剩下所有的译文给最后一条原文
+                                if (strsOut.length > strs.length && strs.length == (i + 1)) {
+                                    patentRight.setContentOut(String.join(" ", Arrays.copyOfRange(strsOut, i, strsOut.length)));
+                                } else {
+                                    patentRight.setContentOut(strsOut[i]);
+                                }
+                            }
+                            patentRights.add(patentRight);
+                        } else if (matcher3.find()) {
+                            StringBuilder builder = new StringBuilder();
+                            for (int sort = 0; sort < strs.length; sort++) {
+                                if (sort == i) {
+                                    continue;
+                                }
+                                builder.append(i).append(",");
+                            }
+                            RePatentClaim patentRight = new RePatentClaim()
+                                    .setPatentId(params.getPatentId())
+                                    .setType(0)
+                                    .setContent(strs[i])
+                                    .setSort(i)
+                                    .setParentSort(builder.substring(0, builder.lastIndexOf(",")));
+                            if (strsOut.length - 1 >= i) {
+                                //当翻译的长度大于原文权要的长度时，将剩下所有的译文给最后一条原文
+                                if (strsOut.length > strs.length && strs.length == (i + 1)) {
+                                    patentRight.setContentOut(String.join(" ", Arrays.copyOfRange(strsOut, i, strsOut.length)));
+                                } else {
+                                    patentRight.setContentOut(strsOut[i]);
+                                }
+                            }
+                            patentRights.add(patentRight);
+                        }
+
+                    } else {
+                        RePatentClaim patentRight = new RePatentClaim()
+                                .setPatentId(params.getPatentId())
+                                .setType(1)
+                                .setContent(strs[i])
+                                .setSort(i)
+                                .setParentSort("-1");
+                        if (strsOut.length - 1 >= i) {
+                            //当翻译的长度大于原文权要的长度时，将剩下所有的译文给最后一条原文
+                            if (strsOut.length > strs.length && strs.length == (i + 1)) {
+                                patentRight.setContentOut(String.join(" ", Arrays.copyOfRange(strsOut, i, strsOut.length)));
+                            } else {
+                                patentRight.setContentOut(strsOut[i]);
+                            }
+                        }
+                        patentRights.add(patentRight);
+                    }
+                }
+            }
+
+            return patentRights;
+        } catch (Exception e) {
+            e.printStackTrace();
+            ArrayList<RePatentClaim> patentRights = new ArrayList<>();
+            patentRights.add(new RePatentClaim().setPatentId(params.getPatentId()).setContent(params.getContent()).setContentOut(params.getContentOut()).setType(1).setSort(0).setParentSort("-1"));
+            return patentRights;
+        }
+    }
+
+}

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

@@ -0,0 +1,84 @@
+package cn.cslg.pas.common.vo;
+
+
+
+
+import io.swagger.v3.oas.annotations.media.Schema;
+import lombok.Data;
+import lombok.experimental.Accessors;
+
+
+/**
+ * @author lrj
+ * @date 2022-11-9
+ * @description 任务VO类
+ */
+@Data
+@Accessors(chain = true)
+@Schema(description="分配任务VO",required = true)
+public class CompareMessageVO {
+    private Integer id;
+    @Schema(description = "标的说明")
+    private String targetDescription;
+    @Schema(description = "标的说明2")
+    private String targetDescription2;
+    @Schema(description = "对比说明")
+    private String compareDescription;
+
+    @Schema(description = "对比说明2")
+    private String compareDescription2;
+    @Schema(description = "对比结果")
+    private Integer compareResult;
+    @Schema(description = "对比结果")
+    private String resultStr;
+    @Schema(description = "对比结果")
+    private Integer compareResult2;
+
+    @Schema(description = "专利号")
+    private String signPatentNo;
+
+    /**
+     * 特征翻译
+     */
+    @Schema(description = "特征翻译")
+    private String contentOut;
+    /**
+     * 特征
+     */
+    @Schema(description = "特征")
+    private String content;
+
+    /**
+     * 所属报告
+     */
+    @Schema(description = "所属报告")
+    private Integer reportId;
+    /**
+     *  解释
+     */
+    @Schema(description = "解释")
+    private String explainText;
+    /**
+     *  拆分类型
+     */
+    @Schema(description = "拆分类型")
+    private Integer splitBy;
+    /**
+     *  拆分方式
+     */
+    @Schema(description = "拆分方式")
+    private Integer splitType;
+    @Schema(description = "权要名")
+    private String rightName;
+    @Schema(description = "权要类型")
+    private Integer rightType;
+    @Schema(description = "权要类型")
+    private Integer featuresOrder;
+    @Schema(description = "任务ID")
+    private Integer taskId;
+    @Schema(description = "权要ID")
+    private Integer rightId;
+    @Schema(description = "对比记录Id")
+    private Integer CMid;
+
+}

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

@@ -0,0 +1,32 @@
+package cn.cslg.pas.common.vo;
+
+import lombok.Data;
+import lombok.experimental.Accessors;
+
+/**
+ * 权利要求
+ */
+@Accessors(chain = true)
+@Data
+public class PatentRightParams {
+    /**
+     * 专利id
+     */
+    private Integer patentId;
+    /**
+     * 专利号
+     */
+    private String patentNo;
+    /**
+     * 原文
+     */
+    private String content;
+    /**
+     * 译文
+     */
+    private String contentOut;
+    /**
+     * 独立权要
+     */
+    private String selfContent;
+}

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

@@ -0,0 +1,68 @@
+package cn.cslg.pas.common.vo;
+
+import cn.cslg.pas.domain.business.Feature;
+
+import com.baomidou.mybatisplus.annotation.TableField;
+import lombok.Data;
+import lombok.experimental.Accessors;
+
+import java.util.List;
+
+/**
+ * @author 李仁杰
+ * @date 2022-11-8
+ * @description  返回包含拆分好的特征的权要
+ */
+
+@Data
+@Accessors(chain = true)
+public class PatentRightVo {
+    /**
+     * 权要名
+     */
+    private String RightName;
+    /**
+     * 专利号
+     */
+    private String signPatentNo;
+    /**
+     * 特征拆分人ID
+     */
+    private Integer partnerId;
+    /**
+     * 专利ID
+     */
+    private Integer patentId;
+
+    /**
+     * 内容
+     */
+    private String contentOut;
+
+    /**
+     * 内容
+     */
+    private String content;
+    /**
+     * 类型
+     */
+    private Integer type;
+
+    private Integer sort;
+
+    /**
+     * 所属报告
+     */
+    private Integer projectId;
+    /**
+     * 特征集合
+     */
+    private List<Feature> features;
+    /**
+     *
+     */
+    private List<CompareMessageVO> compareMessageVOS;
+    
+
+
+}

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

@@ -0,0 +1,47 @@
+package cn.cslg.pas.common.vo;
+
+import lombok.Data;
+import lombok.experimental.Accessors;
+/**
+ * 专利权利要求
+ * @TableName os_patent_right
+ */
+@Accessors(chain = true)
+@Data
+
+public class RePatentClaim {
+
+
+
+        private Integer id;
+
+        /**
+         * 专利ID
+         */
+        private Integer patentId;
+
+        /**
+         * 内容
+         */
+        private String contentOut;
+
+        /**
+         * 内容
+         */
+        private String content;
+
+        /**
+         * 类型
+         */
+        private Integer type;
+
+        private Integer sort;
+
+        private String rightName;
+        /**
+         * 父权要的排序号
+         */
+        private String parentSort;
+
+
+}

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

@@ -1,15 +1,15 @@
 package cn.cslg.pas.common.vo;
 
 
-import cn.cslg.pas.common.model.importTaskModel.*;
 
+
+import cn.cslg.pas.common.model.importTaskModel.*;
 import cn.cslg.pas.domain.es.Patent;
 import lombok.Data;
 import lombok.experimental.Accessors;
 import org.apache.poi.ss.usermodel.PictureData;
 
 import java.util.List;
-
 /**
  * @author 沈永艺
  * @date 2022/7/1

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

@@ -0,0 +1,36 @@
+package cn.cslg.pas.common.vo.business;
+
+import com.fasterxml.jackson.annotation.JsonProperty;
+import io.swagger.v3.oas.annotations.media.Schema;
+import lombok.Data;
+import lombok.experimental.Accessors;
+
+/**
+ * @author lrj
+ * @date 2022-11-11
+ * @description 审核任务VO类
+ */
+@Data
+@Accessors(chain = true)
+@Schema(description = "拆分VO类", required = true)
+public class SplitVO {
+    @Schema(description = "专利号")
+    private String patentNo;
+    /**
+     * 0仅拆主权要 1全部拆分
+     */
+    @Schema(description = "拆分类型")
+    private Integer splitType;
+    /**
+     * 0逗号拆分 1分号拆分 2逗号和分号拆分
+     */
+    @Schema(description = "拆分形式")
+    private Integer splitBy;
+    @JsonProperty("ReportId")
+    @Schema(description = "报告Id")
+    private Integer projectId;
+    @Schema(description = "任务Id")
+    private Integer taskId;
+
+
+}

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

@@ -0,0 +1,36 @@
+package cn.cslg.pas.controller;
+
+import cn.cslg.pas.common.core.base.Constants;
+import cn.cslg.pas.common.utils.Response;
+import cn.cslg.pas.common.vo.business.SplitVO;
+import cn.cslg.pas.service.business.FeatureService;
+import io.swagger.v3.oas.annotations.Operation;
+import lombok.extern.slf4j.Slf4j;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.web.bind.annotation.PostMapping;
+import org.springframework.web.bind.annotation.RequestBody;
+import org.springframework.web.bind.annotation.RequestMapping;
+import org.springframework.web.bind.annotation.RestController;
+
+
+/**
+ * 特征Controller层
+ * @Author lrj
+ * @Date 2023/12/5
+ */
+@Slf4j
+@RequestMapping(Constants.API_XiaoSHI + "/feature")
+@RestController
+public class FeatureController {
+    @Autowired
+    private FeatureService featureService;
+
+    @Operation(summary = "查询特征")
+    @PostMapping("/spiltFeature")
+    public Response queryCustomField(@RequestBody SplitVO splitVO) throws Exception {
+
+        return null;
+    }
+
+
+}

src/main/java/cn/cslg/pas/domain/business/Feature.java

@@ -69,5 +69,4 @@ public class Feature extends BaseEntity<Feature> {
      */
     @TableField(value = "create_time")
     private Date createTime;
-
 }

src/main/java/cn/cslg/pas/domain/business/ReportProject.java

@@ -90,4 +90,9 @@ public class ReportProject extends BaseEntity<ReportProject> {
     @TableField(value = "cron_description")
     private String cronDescription;
 
+    @TableField(value = "split_by")
+    private Integer splitBy;
+
+    @TableField(value = "split_type")
+    private Integer splitType;
 }

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

@@ -1,5 +1,7 @@
 package cn.cslg.pas.mapper;
 
+import cn.cslg.pas.domain.business.Feature;
+import com.baomidou.mybatisplus.core.mapper.BaseMapper;
 import org.springframework.stereotype.Repository;
 
 /**
@@ -7,5 +9,5 @@ import org.springframework.stereotype.Repository;
  * @Date 2023/12/5
  */
 @Repository
-public interface FeatureMapper {
+public interface FeatureMapper extends BaseMapper<Feature> {
 }

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

@@ -1,8 +1,216 @@
 package cn.cslg.pas.service.business;
 
+import cn.cslg.pas.common.dto.business.SelectClaimDTO;
+import cn.cslg.pas.common.model.cronModel.PersonnelVO;
+import cn.cslg.pas.common.utils.CacheUtils;
+import cn.cslg.pas.common.utils.PatentRightUtils;
+import cn.cslg.pas.common.vo.PatentRightParams;
+import cn.cslg.pas.common.vo.PatentRightVo;
+import cn.cslg.pas.common.vo.RePatentClaim;
+import cn.cslg.pas.common.vo.business.SplitVO;
+import cn.cslg.pas.domain.business.Feature;
+import cn.cslg.pas.domain.business.ReportProject;
+import cn.cslg.pas.exception.XiaoShiException;
+import cn.cslg.pas.mapper.FeatureMapper;
+import cn.cslg.pas.service.business.es.EsService;
+import cn.dev33.satoken.stp.StpUtil;
+import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
+import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.stereotype.Service;
+import org.springframework.transaction.annotation.Transactional;
+
+import java.io.IOException;
+import java.util.*;
+import java.util.stream.Collectors;
+
 /**
- * @Author xiexiang
+ * @Author lirj
  * @Date 2023/12/5
  */
-public class FeatureService {
+@Service
+public class FeatureService extends ServiceImpl<FeatureMapper, Feature> {
+    @Autowired
+    private CacheUtils cacheUtils;
+    @Autowired
+    private EsService esService;
+    @Autowired
+    private ReportProjectService reportProjectService;
+
+    @Transactional(rollbackFor = Exception.class)
+    public List<PatentRightVo> splitPatentFeature(SplitVO splitVO) throws IOException {
+        String patentNo = splitVO.getPatentNo();
+        Integer projectId = splitVO.getProjectId();
+        Integer splitType = splitVO.getSplitType();
+        Integer splitBy = splitVO.getSplitBy();
+        Integer taskId = splitVO.getTaskId();
+        Boolean ifUpdate = false;
+
+        //当未传入拆分信息时，设置默认值
+        if (splitBy == null) {
+            splitBy = 0;
+        }
+
+        if (splitType == null) {
+            splitType = 0;
+        }
+//        PersonnelVO personnelVO = cacheUtils.getLoginUser(StpUtil.getLoginIdAsInt());
+        PersonnelVO personnelVO = new PersonnelVO();
+        personnelVO.setId("1");
+        personnelVO.setTenantId(1);
+        //根据报告ID查询报告
+        LambdaQueryWrapper<ReportProject> queryWrapper = new LambdaQueryWrapper();
+        queryWrapper.eq(ReportProject::getProjectId, projectId);
+        List<ReportProject> reportProjects = reportProjectService.list(queryWrapper);
+        //未查到报告报错
+        if (reportProjects.size() == 0) {
+            throw new XiaoShiException("未查询到报告");
+        }
+        ReportProject report = reportProjectService.list(queryWrapper).get(0);
+        //如果报告未拆分过权要，或者拆分类型不同则更新报告
+        if (report.getSplitBy() == null || report.getSplitType() == null || report.getSplitBy() != splitBy || report.getSplitType() != splitType) {
+            report.setSplitBy(splitBy);
+            report.setSplitType(splitType);
+            report.updateById();
+            ifUpdate = true;
+        }
+
+        //查询拆分下的权要
+        List<RePatentClaim> patentRights = this.getRightListByNo(patentNo);
+        List<String> flags = new ArrayList<>();
+
+        List<Integer> partRightSorts = new ArrayList<>();  //权要sorts
+        if (!ifUpdate) {
+            if (splitBy == 0) {  //当splitBy=0时仅仅根据“,”拆解
+                flags.add(",");
+                flags.add("，");
+            } else if (splitBy == 1) {  //当splitBy=1时仅仅根据“;“拆解
+                flags.add(";");
+                flags.add("；");
+            } else if (splitBy == 2) {  //当splitBy=2时根据“;“和”,”拆解
+                flags.add(";");
+                flags.add("；");
+                flags.add(",");
+                flags.add("，");
+            }
+            if (splitType.equals(0)) {  //当splitType=0仅拆解主权要
+                partRightSorts = patentRights.stream().filter(item -> item.getType().equals(1)).map(RePatentClaim::getSort).collect(Collectors.toList());
+            } else if (splitType.equals(1)) {  //当splitType=1拆解全部权要
+                partRightSorts = patentRights.stream().map(RePatentClaim::getSort).collect(Collectors.toList());
+            }
+        }
+
+        LambdaQueryWrapper<Feature> wrapper = new LambdaQueryWrapper<>();
+        wrapper.eq(Feature::getProjectId, projectId)
+                .eq(Feature::getPatentNo, patentNo);
+        List<Feature> allFeatures = new ArrayList<>();
+        if (!ifUpdate) {
+            allFeatures = this.list(wrapper);
+        }
+        List<PatentRightVo> patentRightVos = new ArrayList<>();
+        //将拆解的权要和特征装载到对象PatentRightVo
+        for (int i = 0; i < patentRights.size(); i++) {
+            List<Feature> featureList = new ArrayList<>();
+            Integer sort = patentRights.get(i).getSort();
+            //当更新拆分时
+            if (ifUpdate) {
+                //删除原来的拆分特征
+                this.remove(wrapper);
+
+                //根据拆分方式返回特征
+                List<String> contents = Arrays.asList(patentRights.get(i).getContent());
+
+                //如果是需要拆解的权要
+                if (partRightSorts.contains(patentRights.get(i).getSort())) {
+                    //获得权要的原文并且拆解
+                    contents = this.splitStringByFlags(patentRights.get(i).getContent(), flags);
+                }
+                for (int t = 0; t < contents.size(); t++) {
+                    Feature feature = new Feature();
+                    feature.setRightSort(patentRights.get(i).getSort());
+                    feature.setPatentNo(patentNo);
+                    feature.setProjectId(projectId);
+                    feature.setContent(contents.get(t));
+                    feature.setCreateId(personnelVO.getId());
+                    feature.setRightType(patentRights.get(i).getType());
+                    featureList.add(feature);
+                }
+                if (featureList.size() > 0) {
+                    this.saveBatch(featureList);
+                }
+            }
+            //当不更新时，返回信息
+            else {
+                featureList = allFeatures.stream().filter(item -> item.getRightSort().equals(sort)).collect(Collectors.toList());
+
+            }
+            PatentRightVo patentRightVo = new PatentRightVo();
+            patentRightVo.setPatentId(patentRights.get(i).getPatentId());
+            patentRightVo.setFeatures(featureList);
+            patentRightVo.setContent(patentRights.get(i).getContent());
+            patentRightVo.setSort(patentRights.get(i).getSort());
+            patentRightVo.setType(patentRights.get(i).getType());
+            patentRightVo.setContentOut(patentRights.get(i).getContentOut());
+            patentRightVo.setProjectId(projectId);
+            patentRightVo.setRightName("权要" + sort);
+            patentRightVo.setSignPatentNo(patentNo);
+            patentRightVos.add(patentRightVo);
+        }
+        return patentRightVos;
+    }
+
+
+    //根据符号拆分字符串
+    public List<String> splitStringByFlags(String sentence, List<String> flags) {
+        List<String> sectences = new ArrayList<>();
+//如果字符串为空则返回一个包含空字符串的list
+        if (sentence == null) {
+            sectences.add("");
+            return sectences;
+        }
+        sectences.add(sentence);
+        for (int i = 0; i < flags.size(); i++) {
+            List<String> tem = new ArrayList<>();
+            for (int t = 0; t < sectences.size(); t++) {
+                List<String> attrs = Arrays.asList(sectences.get(t).split(flags.get(i)));
+                for (int v = 0; v < attrs.size(); v++) {
+                    if (v < attrs.size() - 1) {
+                        attrs.set(v, attrs.get(v) + flags.get(i));
+                    }
+                    if (attrs.get(v).equals("其特征在于" + flags.get(i))) {
+                        tem.set(tem.size() - 1, tem.get(tem.size() - 1) + attrs.get(v));
+                    } else {
+                        tem.add(attrs.get(v));
+                    }
+                }
+            }
+            sectences = tem;
+
+        }
+        return sectences;
+
+    }
+
+    @Transactional(rollbackFor = Exception.class)
+    public List<RePatentClaim> getRightListByNo(String patentNo) throws IOException {
+        //从pas获得拆分后的权要
+        SelectClaimDTO selectClaimDTO = null;
+        try {
+            selectClaimDTO = esService.selectClaim(patentNo);
+        } catch (Exception e) {
+            throw new XiaoShiException("未查询到权要");
+        }
+        if (selectClaimDTO == null) {
+            throw new XiaoShiException("未查询到权要");
+        }
+        String patentRight = selectClaimDTO.getClaim();
+        PatentRightParams params = new PatentRightParams();
+        params.setContent(patentRight);
+        params.setPatentNo(patentNo);
+        List<RePatentClaim> patentRights = PatentRightUtils.formatPatentRight(params);
+        patentRights.forEach(item -> {
+            item.setRightName("权要" + (item.getSort() + 1));
+        });
+        return patentRights;
+    }
 }

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

@@ -9,6 +9,7 @@ import cn.cslg.pas.common.model.cronModel.SystemFile;
 import cn.cslg.pas.common.model.request.GroupRequest;
 import cn.cslg.pas.common.model.request.QueryRequest;
 import cn.cslg.pas.common.utils.*;
+import cn.cslg.pas.common.vo.ImportTaskAMVO;
 import cn.cslg.pas.common.vo.business.ImportTaskVO;
 import cn.cslg.pas.domain.business.*;
 import cn.cslg.pas.exception.UnLoginException;
@@ -248,8 +249,8 @@ public class ImportTaskService extends ServiceImpl<ImportTaskMapper, ImportTask>
         return null;
     }
 
-
     private void loadImportTask(List<ImportTaskVO> importTaskVOS) throws IOException {
+        List<ImportTaskAMVO> importTaskAMVOS =schedulingTaskService.getImportTaskAMVOs();
         List<String> createIds = new ArrayList<>();
         importTaskVOS.forEach(item -> {
             if (item.getCreateId() != null) {
@@ -271,7 +272,6 @@ public class ImportTaskService extends ServiceImpl<ImportTaskMapper, ImportTask>
         lambdaQueryWrapper.eq(SystemDict::getGroupType, "IMPORT_TASK");
         List<SystemDict> systemDictList = systemDictService.list(lambdaQueryWrapper);
         for (ImportTaskVO importTaskVO : importTaskVOS) {
-
             //装载创建人
             Personnel personnel = personnels.stream().filter(item -> item.getId().equals(importTaskVO.getCreateId())).findFirst().orElse(null);
             if (personnel != null) {
@@ -296,22 +296,25 @@ public class ImportTaskService extends ServiceImpl<ImportTaskMapper, ImportTask>
 
             long percentage = (long) Math.floor((importTaskVO.getDoneNum() + 0D) / importTaskVO.getAllNum() * 100D);
             importTaskVO.setPercentage(percentage);
-        }
 
 
+            //装载正在进行中任务的完成条数
+          ImportTaskAMVO importTaskAMVO =  importTaskAMVOS.stream().filter(item->item.getId().equals(importTaskVO.getId())).findFirst().orElse(null);
+        if(importTaskAMVO!=null){
+            importTaskVO.setDoneNum(importTaskAMVO.getDoneNum());
+        }
+        }
+
     }
 
 
     private String setImportTaskName(ImportTaskCondition importTaskCondition, String name) {
-
-
         //装载名称
         String type = "";
         String toName = "";
         String to = "";
         String taskName = "";
         if (importTaskCondition.getType().equals(2)) {
-
             type = "【专利号】";
         } else if (importTaskCondition.getType().equals(3) || importTaskCondition.getType().equals(4)) {
             type = "【检索式】";

src/main/java/cn/cslg/pas/service/business/es/EsService.java

@@ -761,14 +761,14 @@ public class EsService {
         long total = response.hits().total().value();
         for (Hit<Patent> hit : hits) {
             Patent esMess = hit.source();
-            dto.setClaim(JSON.toJSONString(esMess.getClaim()));
-//            if (esMess != null) {
-//                String claim = StringUtils.strip(JSON.toJSONString(esMess.getClaim()), "[]");
-//                ClaimDetailDTO claimDetailDTO = JSONObject.parseObject(claim, ClaimDetailDTO.class);
-//                if (claimDetailDTO.getIfOrigin()) {
-//                    dto.setClaim(claimDetailDTO.getTextContent());
-//                }
-//            }
+//            dto.setClaim(JSON.toJSONString(esMess.getClaim()));
+            if (esMess != null) {
+                String claim = StringUtils.strip(JSON.toJSONString(esMess.getClaim()), "[]");
+                ClaimDetailDTO claimDetailDTO = JSONObject.parseObject(claim, ClaimDetailDTO.class);
+                if (claimDetailDTO.getIfOrigin()) {
+                    dto.setClaim(claimDetailDTO.getTextContent());
+                }
+            }
         }
         return dto;
     }

src/main/java/cn/cslg/pas/service/importPatent/ImportFromWebToEsService.java

@@ -216,15 +216,19 @@ public class ImportFromWebToEsService implements PatentImportImp {
                         uploadPatentWebDTO.setTotalCounter(addPatentCounter);
                         uploadPatentWebDTO.setHaveSaveCounter(0);
                         if (ifCataloguing == '1') {
+                            Thread.sleep(100);
                             getCataloguingFromWebThread.awakeTask(uploadPatentWebDTO);
                         }
                         if (ifAddPicture == '1') {
+                            Thread.sleep(100);
                             getPatentPictureFromWebThread.awakeTask(uploadPatentWebDTO);
                         }
                         if (ifAddFullText == '1') {
+                            Thread.sleep(100);
                             getRightAndFullTextFromWebThread.awakeTask(uploadPatentWebDTO);
                         }
                         if (ifPdf == '1') {
+                            Thread.sleep(100);
                             getPatentPDFFromWebThread.awakeTask(uploadPatentWebDTO);
                         }
                     }
@@ -232,7 +236,6 @@ public class ImportFromWebToEsService implements PatentImportImp {
                 }
                 doneNum =overNum;
             }
-
             if (ifCataloguing == '1') {
                 getCataloguingFromWebThread.setIfProductAll(true);
             }

src/main/java/cn/cslg/pas/service/importPatent/SchedulingTaskService.java

@@ -112,4 +112,8 @@ public class SchedulingTaskService {
         ImportTaskAMVO importTaskAMVO = importTaskAMVOS.stream().filter(item -> item.getId().equals(taskId)).findFirst().orElse(null);
         importTaskAMVO.setState(state);
     }
+
+    public List<ImportTaskAMVO> getImportTaskAMVOs(){
+        return this.importTaskAMVOS;
+    }
 }

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

@@ -0,0 +1,41 @@
+package cn.cslg.pas.service;
+
+import cn.cslg.pas.common.dto.business.ProductMarketDataDTO;
+import cn.cslg.pas.common.vo.PatentRightVo;
+import cn.cslg.pas.common.vo.business.SplitVO;
+import cn.cslg.pas.controller.ProductMarketDataController;
+import cn.cslg.pas.service.business.FeatureService;
+import cn.cslg.pas.service.business.ProductMarketDataService;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.boot.test.context.SpringBootTest;
+import org.springframework.test.context.junit4.SpringRunner;
+
+import java.text.SimpleDateFormat;
+import java.util.Date;
+import java.util.List;
+
+/**
+ * @Author xiexiang
+ * @Date 2023/11/16
+ */
+@SpringBootTest
+@RunWith(SpringRunner.class)
+public class FeatureTests {
+    @Autowired
+    private FeatureService featureService;
+
+    @Test
+    public void splitPantentFeature() throws Exception {
+        SplitVO splitVO =new SplitVO();
+        splitVO.setSplitBy(0);
+        splitVO.setSplitType(0);
+        splitVO.setProjectId(51);
+        splitVO.setPatentNo("CN102324864A");
+  List<PatentRightVo> a = featureService.splitPatentFeature(splitVO);
+     System.out.println(a);
+    }
+
+
+}