3/15 权要拆分修改

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

@@ -30,8 +30,6 @@ public class PatentRightUtils {
             }
             //原文
             String content = params.getContent();
-            //译文
-            String contentOut = params.getContentOut();
 
             //创建一个权要集合
             ArrayList<RePatentClaim> patentRights = new ArrayList<>();
@@ -41,9 +39,6 @@ public class PatentRightUtils {
                 return patentRights;
             }
 
-            if (contentOut == null) {
-                contentOut = "";
-            }
 
             //将原文和译文的所有换行符 "\r\n"或是"\n" 替换成 "@"，这样首先可以使得全文连在一起，其次再根据特殊符号@拆分权要
             if (content.contains("\r\n")) {
@@ -53,15 +48,6 @@ public class PatentRightUtils {
                 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("权利要求")) {
@@ -78,27 +64,19 @@ public class PatentRightUtils {
                     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]+";
@@ -137,14 +115,7 @@ public class PatentRightUtils {
                                     .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);
@@ -154,9 +125,6 @@ public class PatentRightUtils {
                                     .setContent(strs[i])
                                     .setSort(i)
                                     .setParentSort((Integer.parseInt(parentNum) - 1) + "");
-                            if (strsOut.length - 1 >= i) {
-                                patentRight.setContentOut(strsOut[i]);
-                            }
                             patentRights.add(patentRight);
                         }
 
@@ -167,136 +135,113 @@ public class PatentRightUtils {
                                 .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")) {
+                if (!content.equals("") && content.contains("[1]")) {
+                    content = content.substring(content.indexOf("["));
+                } 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]")) {
+                } else if (content.contains("[001]") || content.contains("[1]")) {
                     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));
+                    String splitMe = matcher.group();
+                    if (splitMe.contains("[")) {
+                        splitMe = "\\" + splitMe;
+                    }
+                    String p = "\n" + splitMe;
+
+                    content = content.replaceFirst(splitMe, p);
                 }
+
                 content = content.replaceAll("@", "");
-                contentOut = contentOut.replaceAll("@", "");
+                content = content.replaceFirst("\n", "");
                 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";
+                String regex5 = "(Anspruch [0-9]+ oder [0-9]+)|(Ansprüche [0-9]+ bis [0-9]+)";
+                String regex4 = "Anspruch [0-9]+";
                 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("或");
+
+                    Matcher matcher1 = Pattern.compile(regex1).matcher(strs[i]);
+                    Matcher matcher2 = Pattern.compile(regex2).matcher(strs[i]);
+                    Matcher matcher3 = Pattern.compile(regex3).matcher(strs[i]);
+                    Matcher matcher4 = Pattern.compile(regex4).matcher(strs[i]);
+                    Matcher matcher5 = Pattern.compile(regex5).matcher(strs[i]);
+                    Boolean flag1 =matcher1.find();
+                    Boolean flag2 =matcher2.find();
+                    Boolean flag3 =matcher3.find();
+                    Boolean flag4 =matcher4.find();
+                    Boolean flag5 =matcher5.find();
+
+                    if (flag2 || flag5) {
+                        List<String> parentNums = new ArrayList<>();
+                        if (flag2) {
+                            parentNums = getNums(matcher2.group());
+                        } else if (flag5) {
+                            parentNums = getNums(matcher5.group());
+                        }
+                        StringBuilder builder = new StringBuilder();
+                        for (int j = Integer.parseInt(parentNums.get(0)) - 1; j < Integer.parseInt(parentNums.get(parentNums.size() - 1)); j++) {
+                            if ((builder + "").equals("")) {
+                                builder.append(j);
                             } 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()
-                                    .setPatentNo(params.getPatentNo())
-                                    .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]);
-                                }
+                                builder.append(",").append(j);
                             }
-                            patentRights.add(patentRight);
-                        } else if (matcher1.find()) {
-                            String parentNum = matcher1.group().substring(matcher1.group().indexOf("m") + 2);
-                            RePatentClaim patentRight = new RePatentClaim()
-                                    .setPatentNo(params.getPatentNo())
-                                    .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()
-                                    .setPatentNo(params.getPatentNo())
-                                    .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]);
-                                }
+                        }
+                        RePatentClaim patentRight = new RePatentClaim()
+                                .setPatentNo(params.getPatentNo())
+                                .setType(0)
+                                .setContent(strs[i])
+                                .setSort(i)
+                                .setParentSort(builder + "");
+                        patentRights.add(patentRight);
+                    } else if (flag1 || flag4) {
+                        String parentNum = null;
+                        if (flag1) {
+                            parentNum = getNums(matcher1.group()).get(0);
+                        } else if (flag4) {
+                            parentNum = getNums(matcher4.group()).get(0);
+                        }
+                        RePatentClaim patentRight = new RePatentClaim()
+                                .setPatentNo(params.getPatentNo())
+                                .setType(0)
+                                .setContent(strs[i])
+                                .setSort(i)
+                                .setParentSort((Integer.parseInt(parentNum) - 1) + "");
+                        patentRights.add(patentRight);
+                    } else if (flag3) {
+                        StringBuilder builder = new StringBuilder();
+                        for (int sort = 0; sort < strs.length; sort++) {
+                            if (sort == i) {
+                                continue;
                             }
-                            patentRights.add(patentRight);
+                            builder.append(i).append(",");
                         }
-
+                        RePatentClaim patentRight = new RePatentClaim()
+                                .setPatentNo(params.getPatentNo())
+                                .setType(0)
+                                .setContent(strs[i])
+                                .setSort(i)
+                                .setParentSort(builder.substring(0, builder.lastIndexOf(",")));
+                        patentRights.add(patentRight);
                     } else {
                         RePatentClaim patentRight = new RePatentClaim()
                                 .setPatentNo(params.getPatentNo())
@@ -304,14 +249,6 @@ public class PatentRightUtils {
                                 .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);
                     }
                 }
@@ -343,4 +280,14 @@ public class PatentRightUtils {
         }
         return reStr;
     }
+
+    public static List<String> getNums(String test) {
+        List<String> nums = new ArrayList<>();
+        String regex1 = "[0-9]+";
+        Matcher matcher1 = Pattern.compile(regex1).matcher(test);
+        while (matcher1.find()) {
+            nums.add(matcher1.group());
+        }
+        return nums;
+    }
 }

src/main/java/cn/cslg/pas/service/ReportExportService.java

@@ -17,6 +17,8 @@ import cn.cslg.pas.service.business.*;
 import cn.cslg.pas.service.business.es.*;
 import cn.cslg.pas.service.common.FileManagerService;
 import cn.hutool.core.util.IdUtil;
+import com.alibaba.fastjson.JSON;
+import com.alibaba.fastjson.JSONObject;
 import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
 import com.deepoove.poi.XWPFTemplate;
 import com.deepoove.poi.config.Configure;
@@ -36,6 +38,7 @@ import java.io.IOException;
 import java.text.SimpleDateFormat;
 import java.time.format.DateTimeFormatter;
 import java.util.*;
+import java.util.stream.Collectors;
 
 @Slf4j
 @Service
@@ -101,7 +104,7 @@ public class ReportExportService {
         }
         XWPFTemplate template = null;
         if (report.getReportType() == 0 || report.getReportType() == 2) {
-//           template = this.getstabilityTemplate(report, filePath);
+//           template = this.getstabilityTemplate(projectId, templateFilePath);
         } else if (report.getReportType() == 3) {
             template = this.FTOTemplate(projectId, templateFilePath, templeId);
         } else if (report.getReportType() == 4) {
@@ -471,5 +474,356 @@ public class ReportExportService {
         return template;
 
     }
-
+//    private XWPFTemplate getstabilityTemplate(Integer projectId, String filePath) throws IOException {
+//        List<PatentRight> patentRights = new ArrayList<>();
+//        //装载标的专利信息
+//        Map<String, Object> signPatent = this.signPantentMess(report.getSignPatentNo());
+//        //根据报告Id获得报告信息
+//        // 根据拆分人（报告的创建人）Id和报告ID获得所有特征
+//        LambdaQueryWrapper<Features> allFeaturesWrapper = new LambdaQueryWrapper<>();
+//        allFeaturesWrapper.eq(Features::getReportId, report.getId());
+//        allFeaturesWrapper.and(wrapper -> wrapper.eq(Features::getPartnerId, report.getPersonId()).or().eq(Features::getPartnerId, report.getCreatePersonId()));
+//
+//        List<Features> allFeatures = featureService.list(allFeaturesWrapper);
+//        //根据报告Id 查询出报告下所有的方案
+//        LambdaQueryWrapper<CompareScenarios> queryWrapper = new LambdaQueryWrapper<>();
+//        queryWrapper.eq(CompareScenarios::getReportId, report.getId());
+//        List<CompareScenarios> compareScenarios = compareScenariosService.list(queryWrapper);
+//        List<Integer> scenarioIds = compareScenarios.stream().map(CompareScenarios::getId).collect(Collectors.toList());
+//        //根据对比方案Id 查询所有对比方案和（对比记录-特征）关联信息
+//        List<AssoScenarIOS> scenariosRecords = new ArrayList<>();
+//        if (scenarioIds != null && scenarioIds.size() != 0) {
+//            LambdaQueryWrapper<AssoScenarIOS> queryRecordsByIDs = new LambdaQueryWrapper<>();
+//            queryRecordsByIDs.in(AssoScenarIOS::getScenariosID, scenarioIds);
+//            scenariosRecords = scenariosRecordsService.list(queryRecordsByIDs);
+//        }
+//        //获得对比记录-特征关联ID
+//        List<Integer> recordfeatureRecordIds = scenariosRecords.stream().map(AssoScenarIOS::getFeatureRecordID).collect(Collectors.toList());
+//        //从关联表里获得是公识的特征Id
+//        List<Integer> knowedIds = scenariosRecords.stream().map(AssoScenarIOS::getFeaturesID).collect(Collectors.toList());
+//        //根据对比记录-特征关联ID查出对比记录-特征关联信息
+//        List<AssoRecordsFeature> assoRecordsFeatures = new ArrayList<>();
+//        if (recordfeatureRecordIds != null && recordfeatureRecordIds.size() != 0) {
+//            LambdaQueryWrapper<AssoRecordsFeature> wrapper = new LambdaQueryWrapper<>();
+//            wrapper.in(AssoRecordsFeature::getId, recordfeatureRecordIds);
+//            assoRecordsFeatures = assoRecordsFeatureService.list(wrapper);
+//        }
+//        List<AssoRecordsFeature> finalAsso = assoRecordsFeatures;
+//        //从对比记录-特征关联信息里剔出对比记录Id
+//        List<Integer> recordIds = assoRecordsFeatures.stream().map(AssoRecordsFeature::getRecordsId).collect(Collectors.toList());
+//        //从对比记录-特征关联信息里剔出特征Id
+//        List<Integer> sFeatureIds = assoRecordsFeatures.stream().map(AssoRecordsFeature::getFeatureId).collect(Collectors.toList());
+//        sFeatureIds.addAll(knowedIds);
+//        //根据特征ID查询出报告所有方案的特征
+//        List<Features> sFeatures = new ArrayList<>();
+//        LambdaQueryWrapper<Features> sFeaturesWrapper = new LambdaQueryWrapper<>();
+//        sFeaturesWrapper.eq(Features::getId, sFeatureIds);
+//        if (sFeatures != null && sFeatures.size() != 0) {
+//            sFeatures = featureService.list(sFeaturesWrapper);
+//        }
+//        //根据对比记录ID查询出报告所有方案的对比记录
+//        List<CompareRecords> compareRecords = new ArrayList<>();
+//        if (recordIds != null && recordIds.size() != 0) {
+//            LambdaQueryWrapper<CompareRecords> queryPatentByIDs = new LambdaQueryWrapper<>();
+//            queryPatentByIDs.in(CompareRecords::getId, recordIds);
+//            compareRecords = compareRecordsService.list(queryPatentByIDs);
+//        }
+//        //根据对比记录ID获得专利号
+//        List<String> PatentNos = compareRecords.stream().map(CompareRecords::getPatentNo).collect(Collectors.toList());
+//        PatentVO patentVO = new PatentVO();
+//        patentVO.setPatentNos(PatentNos);
+//        //根据专利号查询专利的排序
+//        LambdaQueryWrapper<CompareFiles> comWrapper = new LambdaQueryWrapper<>();
+//        comWrapper
+//                .eq(CompareFiles::getReportId, report.getId())
+//                .last("ORDER BY IF(isnull(SYS_ORDER),1,0), SYS_ORDER ASC");
+//        ;
+//        List<CompareFiles> compareFiles = compareFilesService.list(comWrapper);
+//        //专利号别名的map
+//        Map<String, Object> OtherName = new HashMap<>();
+//        int flag = 1;
+//        for (CompareFiles item : compareFiles) {
+//            Integer order = item.getSysOrder() == null ? flag : item.getSysOrder();
+//            OtherName.put(item.getPatentNo(), order);
+//            flag++;
+//        }
+//
+//        //根据专利号查询专利详细信息
+//        String resBody = outInterfaceService.getPatentDTOListForRMS(patentVO);
+//        JSONObject jsonObject = JSONObject.parseObject(resBody);
+//        List<JSONObject> patentDTOS = JSON.parseArray(jsonObject.get("data").toString(), JSONObject.class);
+//        //存放专利信息的map集合
+//        List<Map<String, Object>> patentListMaps = new ArrayList<>();
+//        //填充专利数据到patentListMap
+//        for (int i = 0; i < patentDTOS.size(); i++) {
+//            JSONObject item = patentDTOS.get(i);
+//            Map<String, Object> patentListMap = new HashMap<>();
+//            List<JSONObject> applicantJSONs = JSON.parseArray(item.get("applicant").toString(), JSONObject.class);
+//            ;
+//            StringBuilder applicants = new StringBuilder();
+//            applicantJSONs.forEach(tem -> {
+//                applicants.append(tem.get("name") + "\r");
+//            });
+//            //填充相关揭露（对比记录文字和特征组合）
+//            StringBuffer disclosures = new StringBuffer("");
+//            //根据专利号获得对比记录
+//            List<CompareRecords> pantentRecords = compareRecords.stream().filter(tem -> tem.getPatentNo().equals(item.get("publicNo"))).collect(Collectors.toList());
+//            //遍历对比记录根据对比记录获得对比记录-特征关联信息并获得特征ID
+//            for (CompareRecords tem : pantentRecords) {
+//                //填充对比记录文字
+//                disclosures.append(tem.getContent());
+//                disclosures.append("\r");
+//                disclosures.append("(");
+//                disclosures.append(tem.getFields());
+//                disclosures.append("[" + (tem.getPosition()) + "]");
+//                disclosures.append(")");
+//                List<Integer> featuresIds = assoRecordsFeatures.stream().filter(te -> te.getRecordsId().equals(tem.getId())).map(AssoRecordsFeature::getFeatureId).collect(Collectors.toList());
+//                //根据特征Id获得特征内容
+//                List<String> feaListContent = sFeatures.stream().filter(te -> featuresIds.contains(te.getId())).map(Features::getContent).collect(Collectors.toList());
+//                feaListContent.forEach(te -> disclosures.append("(" + te + ")"));
+//                disclosures.append("\n");
+//            }
+//            int order = Integer.parseInt(OtherName.get(item.get("patentNo")).toString());
+//
+//            patentListMap.put("name", item.get("name"));
+//            patentListMap.put("fileName", "D" + order);
+//            patentListMap.put("publicDate", item.get("publicDate"));
+//            patentListMap.put("publicNo", item.get("publicNo"));
+//            patentListMap.put("SSIM", "");
+//            patentListMap.put("applicant", applicants);
+//            patentListMap.put("patentNo", item.get("patentNo"));
+//            patentListMap.put("abstractStr", item.get("abstractStr"));
+//            patentListMap.put("compareFileName", "对比文件" + (order));
+//            patentListMap.put("applicationDate", item.get("applicationDate"));
+//            patentListMap.put("abstractPath", pasFile + item.get("abstractPath"));
+//            patentListMap.put("disclosures", disclosures);
+//            patentListMap.put("order", order);
+//            patentListMaps.add(patentListMap);
+//
+//        }
+//        //存放对比方案信息的map集合
+//        List<Map<String, Object>> scenariosMaps = new ArrayList<>(compareFiles.size());
+//        //存放所有对比方案所有不重复的rightId
+//        List<Integer> rightIds = new ArrayList<>();
+//        for (int i = 0; i < compareScenarios.size(); i++) {
+//            CompareScenarios item1 = compareScenarios.get(i);
+//            //获得单个对比方案的
+//            List<AssoScenarIOS> partScenariosRecords = scenariosRecords.stream().filter(item -> item.getScenariosID().equals(item1.getId())).collect(Collectors.toList());
+//            List<Integer> featureRecordsIds = partScenariosRecords.stream().map(AssoScenarIOS::getFeatureRecordID).collect(Collectors.toList());
+//            List<AssoRecordsFeature> assoRecordsFeatures1 = assoRecordsFeatures.stream().filter(item -> featureRecordsIds.contains(item.getId())).collect(Collectors.toList());
+//            List<Integer> partRecordIds = assoRecordsFeatures1.stream().map(AssoRecordsFeature::getRecordsId).collect(Collectors.toList());
+//            List<Integer> partFetIds = assoRecordsFeatures1.stream().map(AssoRecordsFeature::getFeatureId).collect(Collectors.toList());
+//            //获得公识特征的ID
+//            List<Integer> comFetIds = partScenariosRecords.stream().map(AssoScenarIOS::getFeaturesID).collect(Collectors.toList());
+//            partFetIds.addAll(comFetIds);
+//            //获得单个对比方案的权要的所有特征
+//            List<Features> partFeatures = allFeatures.stream().filter(item -> partFetIds.contains(item.getId())).collect(Collectors.toList());
+//            List<CompareRecords> records = compareRecords.stream().filter(item -> partRecordIds.contains(item.getId())).collect(Collectors.toList());
+//            //获得单条权要所有的特征
+//            List<Features> allRightFeatures = allFeatures.stream().filter(item -> item.getRightId().equals(item1.getRightId())).collect(Collectors.toList());
+//            //存放单条对比结果的map
+//            Map<String, Object> temMap = new HashMap<>();
+//            String a = partFeatures.get(0).getRightName().replace("\r", "");
+//            if (partFeatures.size() != 0 && partFeatures.get(0).getRightType().equals(1)) {
+//                temMap.put("rightName", "独立" + a);
+//            } else {
+//                temMap.put("rightName", "附属" + a);
+//            }
+//            temMap.put("rightId", item1.getRightId());
+//            if (report.getType() == 1) {
+//                String rightContent = patentRights.stream().filter(t -> t.getSort().equals(item1.getRightId())).map(PatentRight::getContent).findFirst().orElse("");
+//                temMap.put("rightContent", rightContent);
+//            }
+//            temMap.put("remark", item1.getContrastResult());
+//            // 从关联数据里获得特征id
+//            if (!rightIds.contains(item1.getRightId())) {
+//                rightIds.add(item1.getRightId());
+//            }
+//            //存放对比方案每一个特征记录
+//            List<Map<String, Object>> maps = new ArrayList<>();
+//            allRightFeatures.forEach(tem -> {
+//
+//                List<AssoRecordsFeature> assoRecordsFeatures2 = assoRecordsFeatures1.stream().filter(item -> item.getFeatureId().equals(tem.getId())).collect(Collectors.toList());
+//                if (comFetIds.contains(tem.getId())) {
+//                    Map<String, Object> map = new LinkedHashMap<>();
+//                    map.put("featureContent", tem.getContent());
+//                    map.put("compareResult", "公识");
+//                    map.put("compareContent", "");
+//                    maps.add(map);
+//                } else if (assoRecordsFeatures2.size() != 0) {
+//                    Map<String, Object> map = new LinkedHashMap<>();
+//                    map.put("featureContent", tem.getContent());
+//                    List<Map<String, Object>> temMap1 = new ArrayList<>();
+//                    AssoRecordsFeature assoRecordsFeature = assoRecordsFeatures2.get(0);
+//                    CompareRecords record = records.stream().filter(item -> item.getId().equals(assoRecordsFeature.getRecordsId())).findFirst().orElse(new CompareRecords());
+//                    String compareContent = "";
+//                    //获取对比内容
+//                    String content = record.getContent() != null ? record.getContent() : "";
+//                    //获得对比专利号
+//                    String patentNo = record.getPatentNo() != null ? record.getPatentNo() : "";
+//                    if (OtherName.containsKey(patentNo)) {
+//                        patentNo = "D" + OtherName.get(patentNo).toString() + ":";
+//                    } else if (!patentNo.equals("")) {
+//                        patentNo += ":";
+//                    }
+//                    //获得解析过程
+//                    String paresingProcess = record.getParesingProcess() != null ? "(" + record.getParesingProcess() + ")" : "";
+//                    compareContent = patentNo + content + paresingProcess;
+//                    //获取对比专利号
+//                    if (maps.size() > 0) {
+//                        Map<String, Object> lastMap = maps.get(maps.size() - 1);
+//                        if (lastMap.get("compareContent").toString().equals(compareContent)) {
+//                            lastMap.put("featureContent", lastMap.get("featureContent") + tem.getContent());
+//                        } else {
+//                            map.put("compareResult", assoRecordsFeature.getComResult() != null ? assoRecordsFeature.getComResult() : "不公开");
+//                            map.put("compareContent", compareContent);
+//                            map.put("figure", fileUtils.getSystemPath() + record.getFilePath());
+//                            if (record.getFields() == null && record.getPosition() == null) {
+//                                map.put("position", "");
+//                            } else {
+//                                map.put("position", "\r" + "(" + record.getFields() + "[" + record.getPosition() + "]" + ")");
+//                            }
+//                            maps.add(map);
+//                        }
+//                    } else {
+//                        map.put("compareResult", assoRecordsFeature.getComResult() != null ? assoRecordsFeature.getComResult() : "不公开");
+//                        map.put("compareContent", compareContent);
+//                        map.put("figure", fileUtils.getSystemPath() + record.getFilePath());
+//                        if (record.getFields() == null && record.getPosition() == null) {
+//                            map.put("position", "");
+//                        } else {
+//                            map.put("position", "\r" + "(" + record.getFields() + "[" + record.getPosition() + "]" + ")");
+//                        }
+//                        maps.add(map);
+//                    }
+//
+//                } else {
+//                    Map<String, Object> map = new LinkedHashMap<>();
+//                    map.put("featureContent", tem.getContent());
+//                    map.put("compareResult", "未公开");
+//                    map.put("compareContent", "");
+//                    maps.add(map);
+//                }
+//
+//            });
+//            //方案内容
+//            temMap.put("fileDetails", maps);
+//            //新颖性模块
+//            //获得本方案所有的专利号
+//            List<String> patentNOs = new ArrayList<>();
+//            records.forEach(item -> {
+//                if (!patentNOs.contains(item.getPatentNo())) {
+//                    patentNOs.add(item.getPatentNo());
+//                }
+//            });
+//            //比较所有专利号和权要所有权要的大小，如果相等则将该专利加入到新颖性列表中
+//            List<String> noveltyFiles = new ArrayList<>();
+//            patentNOs.forEach(
+//                    item -> {
+//                        List<Integer> temRecordIds = records.stream().filter(tm -> tm.getPatentNo().equals(item)).map(CompareRecords::getId).collect(Collectors.toList());
+//                        List<Integer> temFIds = finalAsso.stream().filter(tm -> temRecordIds.contains(tm.getRecordsId())).map(AssoRecordsFeature::getFeatureId).collect(Collectors.toList());
+//                        String tmName = item;
+//                        if (OtherName.containsKey(item)) {
+//                            tmName = "D" + OtherName.get(item).toString();
+//                        }
+//                        if (temFIds.size() == allRightFeatures.size()) {
+//                            noveltyFiles.add(tmName);
+//                        }
+//                    }
+//            );
+//            //创造性列表
+//            List<String> creativeFiles = new ArrayList<>();
+//            //当前方案所有的特征Id
+//            records.forEach(
+//                    item -> {
+//                        String tmName = item.getPatentNo();
+//                        if (OtherName.containsKey(tmName)) {
+//                            tmName = "D" + OtherName.get(tmName).toString();
+//                        }
+//                        if (!creativeFiles.contains(tmName)) {
+//                            creativeFiles.add(tmName);
+//                        }
+//                    }
+//            );
+//            List<AssoScenarIOS> andRecords = partScenariosRecords.stream().filter(tm -> tm.getScenariosID().equals(item1.getId()) && tm.getFeaturesID() != 0).collect(Collectors.toList());
+//            if (andRecords.size() != 0) {
+//                creativeFiles.add("C");
+//            }
+//            String creative = creativeFiles.size() == 0 ? "" : StringUtils.join(creativeFiles, "+");
+//            String novelty = noveltyFiles.size() == 0 ? "" : StringUtils.join(noveltyFiles, "-");
+//            //新颖性
+//            temMap.put("novelty", novelty);
+//            //创造性
+//            temMap.put("creative", creative);
+//            scenariosMaps.add(temMap);
+//        }
+//        List<Map<String, Object>> allRightScenarios = new ArrayList<>();
+//        List<Map<String, Object>> resultMaps = new ArrayList<>();
+//        // 存放创造性和新颖性的权要
+//
+//        rightIds.forEach(tem -> {
+//            Map<String, Object> map = new HashMap<>();
+//            Map<String, Object> resultMap = new HashMap<>();
+//            List<Map<String, Object>> rightScenarios = new ArrayList<>();
+//            //存放新颖性信息
+//            List<String> noveList = new ArrayList<>();
+//            List<String> creaList = new ArrayList<>();
+//            //存放创造性信息
+//            for (int t = 0; t < scenariosMaps.size(); t++) {
+//                Map<String, Object> item = scenariosMaps.get(t);
+//                if (item.get("rightId").equals(tem)) {
+//                    item.put("scenariosName", "对比组合" + (t + 1));
+//                    rightScenarios.add(item);
+//                    if (item.get("novelty").toString() != "") {
+//                        if (!noveList.contains(item.get("novelty").toString())) {
+//                            noveList.add(item.get("novelty").toString());
+//                        }
+//                    }
+//                    if (item.get("creative").toString() != "") {
+//                        if (!creaList.contains(item.get("creative").toString())) {
+//                            creaList.add(item.get("creative").toString());
+//                        }
+//                    }
+//                }
+//            }
+//            map.put("rightScenrios", rightScenarios);
+//            map.put("rightName", rightScenarios.get(0).get("rightName"));
+//            String creative = creaList.size() == 0 ? "" : StringUtils.join(creaList, "、");
+//            String novelty = noveList.size() == 0 ? "" : StringUtils.join(noveList, "-");
+//            resultMap.put("rightName", rightScenarios.get(0).get("rightName"));
+//            resultMap.put("rightNovelty", novelty);
+//            resultMap.put("rightCreative", creative);
+//            allRightScenarios.add(map);
+//            resultMaps.add(resultMap);
+//        });
+//        //1.系统数据
+//        //存放单条对比结果的map
+//        Map<String, Object> map = new HashMap<>();
+//        String date = DateUtils.formatDate(new Date(), DateUtils.YYYY_MM_DD);
+//        String[] ds = date.split("-");
+//        map.put("sys", new SystemMO(ds[0], ds[1], ds[2], "", "reportName"));
+//        if (patentListMaps.size() > 1) {
+//            patentListMaps = this.sortMap(patentListMaps);
+//        }
+//        map.put("patentList", patentListMaps);
+//        map.put("combinations", allRightScenarios);
+//        map.put("allResults", resultMaps);
+//        map.put("signPatent", signPatent);
+//        map.put("pantentNo", report.getSignPatentNo());
+//        map.put("rights", signPatent.get("rights"));
+//        // 为表格的显示绑定行循环
+//        LoopRowTableRenderPolicy policy = new LoopRowTableRenderPolicy();
+//        HtmlRenderPolicy htmlRenderPolicy = new HtmlRenderPolicy();
+//        // 将bz设置为行循环绑定的数据源的key,即key是bz的value会在模板中的{{bz}}处进行解析
+//        Configure configure = Configure.builder()
+//                .bind("patentList", policy)
+//                .bind("fileDetails", policy)
+//                .bind("allResults", policy)
+//                .bind("signPatent.rights", policy)
+//                .bind("remark", htmlRenderPolicy)
+//                .build();
+//        // 读取模板、数据并渲染
+//        XWPFTemplate template = XWPFTemplate.compile(filePath, configure).render(map);
+//        return template;
+//    }
 }

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

@@ -1144,11 +1144,7 @@ public class EsService {
             Patent esMess = hit.source();
             if (esMess != null) {
                 dto.setClaimContent(esMess.getClaim());
-                String claim = StringUtils.strip(JSON.toJSONString(esMess.getClaim()), "[]");
-                ContentDetailDTO contentDetailDTO = JSONObject.parseObject(claim, ContentDetailDTO.class);
-                if (contentDetailDTO.getIfOrigin()) {
-                    dto.setClaim(contentDetailDTO.getTextContent().replaceAll("\t", ""));
-                }
+                    dto.setClaim(esMess.getClaim().get(0).getTextContent());
             }
         }
         return dto;

src/main/java/cn/cslg/pas/service/business/invalidReport/PatentClaimHistoryService.java

@@ -201,6 +201,7 @@ public class PatentClaimHistoryService extends ServiceImpl<PatentClaimHistoryMap
             deleteIds = patentClaimHistoryList.stream().map(PatentClaimHistory::getClaimId).collect(Collectors.toList());
         }
         allOriginalClaimIds.removeAll(deleteIds);
+
         // 第一层过滤掉已经被删除掉的权利要求
         List<PatentClaim> firstFilter = patentClaims.stream()
                 .filter(item -> allOriginalClaimIds.contains(item.getId()))
@@ -250,7 +251,7 @@ public class PatentClaimHistoryService extends ServiceImpl<PatentClaimHistoryMap
             PatentClaim patentClaim = patentClaimService.getById(claimId);
             // 过滤出原权利要求表中，比待删除这条权要排序大的那些权利要求
             List<PatentClaim> secondFilter = firstFilter.stream()
-                    .filter(item -> item.getSysOrder() > patentClaim.getSysOrder())
+                    .filter(item -> item.getSysOrder()!=null&&item.getSysOrder() > patentClaim.getSysOrder())
                     .collect(Collectors.toList());
             List<Integer> sortLaterIds = secondFilter.stream().map(PatentClaim::getId).collect(Collectors.toList());
             if (ifFirst) {