4/25

PAS/src/main/java/cn/cslg/pas/common/model/params/PatentRightParams.java

@@ -1,12 +1,32 @@
 package cn.cslg.pas.common.model.params;
 
 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;
 }

PAS/src/main/java/cn/cslg/pas/common/model/vo/TaskVO.java

@@ -2,12 +2,22 @@ package cn.cslg.pas.common.model.vo;
 
 import lombok.Data;
 
+import java.util.List;
+
 @Data
 public class TaskVO extends BaseVO {
     private Integer projectId;
     private Integer status;
     private Integer type;
+    /**
+     * 创建人名称
+     */
     private String createName;
+    /**
+     * 创建人ids
+     */
+    private List<Integer> createPersonIds;
     private String projectName;
     private Integer productId;
+
 }

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

@@ -0,0 +1,269 @@
+package cn.cslg.pas.common.utils;
+
+import cn.cslg.pas.common.model.params.PatentRightParams;
+import cn.cslg.pas.domain.PatentRight;
+import org.springframework.stereotype.Component;
+
+import java.util.ArrayList;
+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 List<PatentRight> formatPatentRight(PatentRightParams params) {
+        //国家
+        String country = params.getPatentNo().substring(0, 2);
+        //原文
+        String content = params.getContent();
+        //译文
+        String contentOut = params.getContentOut();
+
+        //创建一个权要集合
+        ArrayList<PatentRight> patentRights = new ArrayList<>();
+
+        //若权要原文为空，则直接返回空集合
+        if (content == null || content.equals("")) {
+            return patentRights;
+        }
+
+        //先去掉所有换行符，使原文连成一个长字符串
+        if (content.contains("\r\n")) {
+            content = content.replaceAll("\r\n", "");
+        } else {
+            content = content.replaceAll("\n", "");
+        }
+
+        if (contentOut == null) {
+            contentOut = "";
+        }
+        if (contentOut.contains("\r\n")) {
+            contentOut = contentOut.replaceAll("\r\n", "");
+        } else {
+            contentOut = contentOut.replaceAll("\n", "");
+        }
+        //去掉译文的所有空格
+        contentOut = contentOut.replaceAll(" +", "");
+
+        //中日韩专利↓
+        if (country.equals("CN") || country.equals("JP") || country.equals("KR")) {
+            String regex;
+            if (content.contains("。2.")) {
+                regex = "。[0-9]+\\.";
+            } else if (content.contains("。2、")) {
+                regex = "。[0-9]+、";
+            } else if (content.contains("[001]")) {
+                regex = "\\[[0-9]+]";
+            } else if (content.contains("請求項")) {
+                regex = "。【請求項[0-9]+】";
+            } else if (content.contains(".청구항 2")) {
+                regex = "\\.청구항 [0-9]+";
+            } else {
+                regex = "";
+            }
+            Matcher matcher = Pattern.compile(regex).matcher(content);
+            Matcher matcherOut = Pattern.compile(regex).matcher(contentOut);
+            while (matcher.find()) {
+                if (matcher.group().contains(".청구항")) {
+                    //".청구항 2" -> "\\.청구항 2"
+                    String matcherGroup = matcher.group().replace(".", "\\.");
+                    //".청구항 2" -> ".\n청구항 2"
+                    content = content.replaceFirst(matcherGroup, ".\n" + matcherGroup.substring(matcherGroup.indexOf(".") + 1));
+                } else if (matcher.group().contains(".")) {
+                    //"。2." -> "。2\\."
+                    String matcherGroup = matcher.group().replace(".", "\\.");
+                    //"。2." -> "。\n2."
+                    content = content.replaceFirst(matcherGroup, "。\n" + matcherGroup.substring(matcherGroup.indexOf("。") + 1, matcherGroup.indexOf("\\")) + ".");
+                } else if (matcher.group().contains("、") || matcher.group().contains("請求項")) {
+                    content = content.replaceFirst(matcher.group(), "。\n" + matcher.group().substring(matcher.group().indexOf("。") + 1));
+                }
+            }
+            String[] strs = content.split("\n");
+            while (matcherOut.find()) {
+                if (matcherOut.group().contains(".")) {
+                    String matcherOutGroup = matcherOut.group().replace(".", "\\.");
+                    contentOut = contentOut.replaceFirst(matcherOutGroup, "。\n" + matcherOutGroup.substring(matcherOutGroup.indexOf("。") + 1, matcherOutGroup.indexOf("\\")) + ".");
+                } else if (matcherOut.group().contains("、")) {
+                    contentOut = contentOut.replaceFirst(matcherOut.group(), "。\n" + matcherOut.group().substring(matcherOut.group().indexOf("。") + 1));
+                }
+            }
+            String[] 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);
+                            }
+                        }
+                        PatentRight patentRight = new PatentRight()
+                                .setPatentId(params.getPatentId())
+                                .setType(0)
+                                .setContent(strs[i])
+                                .setSort(i)
+                                .setParentSort(builder + "");
+                        if (strsOut.length - 1 >= i) {
+                            patentRight.setContentOut(strsOut[i]);
+                        }
+                        patentRights.add(patentRight);
+                    } else if (matcher1.find()) {
+                        String parentNum = matcher1.group().substring(matcher1.group().indexOf("求") + 1);
+                        PatentRight patentRight = new PatentRight()
+                                .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 {
+                    PatentRight patentRight = new PatentRight()
+                            .setPatentId(params.getPatentId())
+                            .setType(1)
+                            .setContent(strs[i])
+                            .setSort(i)
+                            .setParentSort("-1");
+                    if (strsOut.length - 1 >= i) {
+                        patentRight.setContentOut(strsOut[i]);
+                    }
+                    patentRights.add(patentRight);
+                }
+            }
+
+            //英文专利的权要拆分 ↓
+        } else {
+            content = content.substring(content.indexOf("1."));
+            if (contentOut.contains("1.")) {
+                contentOut = contentOut.substring(contentOut.indexOf("1."));
+            } else {
+                contentOut = contentOut.substring(contentOut.indexOf("1、"));
+            }
+            String regex;
+            if (content.contains("1.")) {
+                regex = "\\.[0-9]+\\. ";
+            } else if (content.contains("1、")) {
+                regex = "\\.[0-9]+\\. ";
+            } else if (content.contains("[001]")) {
+                regex = "\\[[0-9]+]";
+            } else {
+                regex = "";
+            }
+            Matcher matcher = Pattern.compile(regex).matcher(content);
+            Matcher matcherOut = Pattern.compile("。[0-9]+\\.").matcher(contentOut);
+            while (matcher.find()) {
+                String matcherGroup = matcher.group().replace(".", "\\.");
+                content = content.replaceFirst(matcherGroup, ".\n" + matcherGroup.substring(matcherGroup.indexOf(".") + 1, matcherGroup.lastIndexOf("\\")) + ". ");
+            }
+            String[] strs = content.split("\n");
+            while (matcherOut.find()) {
+                String matcherOutGroup = matcherOut.group().replace(".", "\\.");
+                contentOut = contentOut.replaceFirst(matcherOutGroup, "。\n" + matcherOutGroup.substring(matcherOutGroup.indexOf("。") + 1, matcherOutGroup.indexOf("\\")) + ".");
+            }
+            String[] strsOut = contentOut.split("\n");
+            //定义父权要排序号
+            String regex1 = "claim [0-9]+";
+            String regex2 = "claims [0-9]+ or [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]);
+                    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);
+                            }
+                        }
+                        PatentRight patentRight = new PatentRight()
+                                .setPatentId(params.getPatentId())
+                                .setType(0)
+                                .setContent(strs[i])
+                                .setSort(i)
+                                .setParentSort(builder + "");
+                        if (strsOut.length - 1 >= i) {
+                            patentRight.setContentOut(strsOut[i]);
+                        }
+                        patentRights.add(patentRight);
+                    } else if (matcher1.find()) {
+                        String parentNum = matcher1.group().substring(matcher1.group().indexOf("m") + 2);
+                        PatentRight patentRight = new PatentRight()
+                                .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 {
+                    PatentRight patentRight = new PatentRight()
+                            .setPatentId(params.getPatentId())
+                            .setType(1)
+                            .setContent(strs[i])
+                            .setSort(i)
+                            .setParentSort("-1");
+                    if (strsOut.length - 1 >= i) {
+                        patentRight.setContentOut(strsOut[i]);
+                    }
+                    patentRights.add(patentRight);
+                }
+            }
+        }
+
+        return patentRights;
+    }
+
+}

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

@@ -0,0 +1,35 @@
+package cn.cslg.pas.service;
+
+import lombok.RequiredArgsConstructor;
+import lombok.extern.slf4j.Slf4j;
+import okhttp3.OkHttpClient;
+import okhttp3.Request;
+import org.springframework.beans.factory.annotation.Value;
+import org.springframework.stereotype.Service;
+
+import java.io.IOException;
+import java.util.Objects;
+
+/**
+ * 调用外部接口的Service类 PCS:权限系统
+ *
+ * @Author chenyu
+ * @Date 2023/4/25
+ */
+@RequiredArgsConstructor
+@Slf4j
+@Service
+public class OutInterfaceService {
+    @Value("${PCSUrl}")
+    private String PCSUrl;
+
+    public String getPersonIdByNamePCS(String personName) throws IOException {
+        OkHttpClient okHttpClient = new OkHttpClient();
+        Request request = new Request.Builder()
+                .url(PCSUrl + "/permission/api/system/getPersonIdByName?personName=" + personName)
+                .get()
+                .build();
+        return Objects.requireNonNull(okHttpClient.newCall(request).execute().body()).string();
+    }
+
+}

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

@@ -1,6 +1,7 @@
 package cn.cslg.pas.service;
 
 import cn.cslg.pas.common.model.params.PatentRightParams;
+import cn.cslg.pas.common.utils.PatentRightUtils;
 import cn.cslg.pas.common.utils.PatentUtils;
 import cn.cslg.pas.common.utils.Response;
 import cn.cslg.pas.common.utils.StringUtils;
@@ -30,8 +31,8 @@ import java.util.stream.Collectors;
 @Service
 @RequiredArgsConstructor(onConstructor_ = {@Lazy})
 public class PatentRightService extends ServiceImpl<PatentRightMapper, PatentRight> {
-
     private final PatentService patentService;
+    private final PatentRightUtils patentRightUtils;
 
     public List<PatentRight> getPatentRightByPatentNo(String patentNo) {
         Patent patent = patentService.getByPatentNo(patentNo);
@@ -430,290 +431,300 @@ public class PatentRightService extends ServiceImpl<PatentRightMapper, PatentRig
 
     }
 
+    /**
+     * 格式化权要、拆分并理清父子级，insert/update DB
+     *
+     * @param params 权利要求
+     */
     public void updatePatentRight(PatentRightParams params) {
-//        获取国家 公开号前两位
-        String country = PatentUtils.getPatentCountry(params.getPatentNo());
-        //权利要求原文
-        String content = params.getContent();
-        //权利要求译文
-        String contentOut = params.getContentOut();
-        if (StringUtils.isNotEmpty(content)) {
-            //先删除库表中原有该权要
-            this.deleteByPatentId(params.getPatentId());
-//            String[] contentArray = null;
-//            String[] contentOutArray = null;
-//            String[] selfContentArray = null;
-//            switch (country) {
-//                case "JP":
-//                case "CN":
-//                    code = "。";
-//                    if (StringUtils.isNotEmpty(contentOut)) {
-//                        contentOut = contentOut.replaceAll("\n", "");
-//                        contentOutArray = StringUtils.split(contentOut, code);
-//                    }
-//                    if (StringUtils.isNotEmpty(selfContent)) {
-//                        selfContent = selfContent.replaceAll("\n", "");
-//                        selfContentArray = StringUtils.split(selfContent, code);
+        //调用拆分权要工具类格式化并拆分权要理清父子级
+        List<PatentRight> patentRights = patentRightUtils.formatPatentRight(params);
+        //删除库表中原有该权要
+        this.deleteByPatentId(params.getPatentId());
+        this.saveOrUpdateBatch(patentRights);
+
+////        获取国家 公开号前两位
+//        String country = PatentUtils.getPatentCountry(params.getPatentNo());
+//        //权利要求原文
+//        String content = params.getContent();
+//        //权利要求译文
+//        String contentOut = params.getContentOut();
+//        if (StringUtils.isNotEmpty(content)) {
+//            //先删除库表中原有该权要
+//            this.deleteByPatentId(params.getPatentId());
+////            String[] contentArray = null;
+////            String[] contentOutArray = null;
+////            String[] selfContentArray = null;
+////            switch (country) {
+////                case "JP":
+////                case "CN":
+////                    code = "。";
+////                    if (StringUtils.isNotEmpty(contentOut)) {
+////                        contentOut = contentOut.replaceAll("\n", "");
+////                        contentOutArray = StringUtils.split(contentOut, code);
+////                    }
+////                    if (StringUtils.isNotEmpty(selfContent)) {
+////                        selfContent = selfContent.replaceAll("\n", "");
+////                        selfContentArray = StringUtils.split(selfContent, code);
+////                    }
+////                    content = content.replaceAll("\n", "");
+////                    contentArray = StringUtils.split(content, code);
+////                    break;
+////                default:
+////                    code = "\n";
+////                    if (StringUtils.isNotEmpty(contentOut)) {
+////                        contentOutArray = StringUtils.split(contentOut, code);
+////                    }
+////                    if (StringUtils.isNotEmpty(selfContent)) {
+////                        selfContentArray = StringUtils.split(selfContent, code);
+////                    }
+////                    contentArray = StringUtils.split(content, code);
+////            }
+////            for (int i = 0; i < contentArray.length; i++) {
+////                if (StringUtils.isEmpty(contentArray[i])) {
+////                    continue;
+////                }
+////                PatentRight patentRight = new PatentRight();
+////                patentRight.setPatentId(params.getPatentId());
+////                patentRight.setContent(contentArray[i]);
+////                patentRight.setType(0);
+////                patentRight.setSort(i);
+////                if (contentOutArray != null && i < contentOutArray.length) {
+////                    patentRight.setContentOut(contentOutArray[i]);
+////                }
+////                if (selfContentArray != null) {
+////                    String temp = Arrays.stream(selfContentArray).filter(item -> item.equals(patentRight.getContent())).findFirst().orElse(null);
+////                    if (temp != null) {
+////                        patentRight.setType(1);
+////                    }
+////                }
+//            ArrayList<PatentRight> patentRights = new ArrayList<>();
+//            //先去掉所有换行符，使所有内容连起来
+//            if (content.contains("\r\n")) {
+//                content = content.replaceAll("\r\n", "");
+//            } else {
+//                content = content.replaceAll("\n", "");
+//            }
+//            if (contentOut == null) {
+//                contentOut = "";
+//            }
+//            if (contentOut.contains("\r\n")) {
+//                contentOut = contentOut.replaceAll("\r\n", "");
+//            } else {
+//                contentOut = contentOut.replaceAll("\n", "");
+//            }
+//            //去掉译文的所有空格
+//            contentOut = contentOut.replaceAll(" +", "");
+//
+//            //中文专利的权要拆分 ↓
+//            if (country.equals("CN") || country.equals("JP") || country.equals("KR")) {
+//                String regex;
+//                if (content.contains("。2.")) {
+//                    regex = "。[0-9]+\\.";
+//                } else if (content.contains("。2、")) {
+//                    regex = "。[0-9]+[、]";
+//                } else if (content.contains("[001]")) {
+//                    regex = "\\[[0-9]+]";
+//                } else if (content.contains("請求項")) {
+//                    regex = "。【請求項[0-9]+】";
+//                } else if (content.contains("청구항")) {
+//                    regex = "\\.청구항 [0-9]+";
+//                } else {
+//                    regex = "";
+//                }
+//                Matcher matcher = Pattern.compile(regex).matcher(content);
+//                Matcher matcherOut = Pattern.compile(regex).matcher(contentOut);
+//                while (matcher.find()) {
+//                    if (matcher.group().contains("청구항")) {
+//                        String matcherGroup = matcher.group().replace(".", "\\.");
+//                        content = content.replaceFirst(matcherGroup, ".\n" + matcherGroup.substring(matcherGroup.indexOf(".") + 1));
+//                    } else if (matcher.group().contains(".")) {
+//                        String matcherGroup = matcher.group().replace(".", "\\.");
+//                        content = content.replaceFirst(matcherGroup, "。\n" + matcherGroup.substring(matcherGroup.indexOf("。") + 1, matcherGroup.indexOf("\\")) + ".");
+//                    } else if (matcher.group().contains("、") || matcher.group().contains("請求項")) {
+//                        content = content.replaceFirst(matcher.group(), "。\n" + matcher.group().substring(matcher.group().indexOf("。") + 1));
 //                    }
-//                    content = content.replaceAll("\n", "");
-//                    contentArray = StringUtils.split(content, code);
-//                    break;
-//                default:
-//                    code = "\n";
-//                    if (StringUtils.isNotEmpty(contentOut)) {
-//                        contentOutArray = StringUtils.split(contentOut, code);
+//                }
+//                String[] strs = content.split("\n");
+//                while (matcherOut.find()) {
+//                    if (matcherOut.group().contains(".")) {
+//                        String matcherOutGroup = matcherOut.group().replace(".", "\\.");
+//                        contentOut = contentOut.replaceFirst(matcherOutGroup, "。\n" + matcherOutGroup.substring(matcherOutGroup.indexOf("。") + 1, matcherOutGroup.indexOf("\\")) + ".");
+//                    } else if (matcherOut.group().contains("、")) {
+//                        contentOut = contentOut.replaceFirst(matcherOut.group(), "。\n" + matcherOut.group().substring(matcherOut.group().indexOf("。") + 1));
 //                    }
-//                    if (StringUtils.isNotEmpty(selfContent)) {
-//                        selfContentArray = StringUtils.split(selfContent, code);
+//                }
+//                String[] 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);
+//                                }
+//                            }
+//                            PatentRight patentRight = new PatentRight()
+//                                    .setPatentId(params.getPatentId())
+//                                    .setType(0)
+//                                    .setContent(strs[i])
+//                                    .setSort(i)
+//                                    .setParentSort(builder + "");
+//                            if (strsOut.length - 1 >= i) {
+//                                patentRight.setContentOut(strsOut[i]);
+//                            }
+//                            patentRights.add(patentRight);
+//                        } else if (matcher1.find()) {
+//                            String parentNum = matcher1.group().substring(matcher1.group().indexOf("求") + 1);
+//                            PatentRight patentRight = new PatentRight()
+//                                    .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 {
+//                        PatentRight patentRight = new PatentRight()
+//                                .setPatentId(params.getPatentId())
+//                                .setType(1)
+//                                .setContent(strs[i])
+//                                .setSort(i)
+//                                .setParentSort("-1");
+//                        if (strsOut.length - 1 >= i) {
+//                            patentRight.setContentOut(strsOut[i]);
+//                        }
+//                        patentRights.add(patentRight);
 //                    }
-//                    contentArray = StringUtils.split(content, code);
-//            }
-//            for (int i = 0; i < contentArray.length; i++) {
-//                if (StringUtils.isEmpty(contentArray[i])) {
-//                    continue;
 //                }
-//                PatentRight patentRight = new PatentRight();
-//                patentRight.setPatentId(params.getPatentId());
-//                patentRight.setContent(contentArray[i]);
-//                patentRight.setType(0);
-//                patentRight.setSort(i);
-//                if (contentOutArray != null && i < contentOutArray.length) {
-//                    patentRight.setContentOut(contentOutArray[i]);
+//
+//                //英文专利的权要拆分 ↓
+//            } else {
+//                content = content.substring(content.indexOf("1."));
+//                if (contentOut.contains("1.")) {
+//                    contentOut = contentOut.substring(contentOut.indexOf("1."));
+//                } else {
+//                    contentOut = contentOut.substring(contentOut.indexOf("1、"));
+//                }
+//                String regex;
+//                if (content.contains("1.")) {
+//                    regex = "\\.[0-9]+\\. ";
+//                } else if (content.contains("1、")) {
+//                    regex = "\\.[0-9]+\\. ";
+//                } else if (content.contains("[001]")) {
+//                    regex = "\\[[0-9]+]";
+//                } else {
+//                    regex = "";
+//                }
+//                Matcher matcher = Pattern.compile(regex).matcher(content);
+//                Matcher matcherOut = Pattern.compile("。[0-9]+\\.").matcher(contentOut);
+//                while (matcher.find()) {
+//                    String matcherGroup = matcher.group().replace(".", "\\.");
+//                    content = content.replaceFirst(matcherGroup, ".\n" + matcherGroup.substring(matcherGroup.indexOf(".") + 1, matcherGroup.lastIndexOf("\\")) + ". ");
 //                }
-//                if (selfContentArray != null) {
-//                    String temp = Arrays.stream(selfContentArray).filter(item -> item.equals(patentRight.getContent())).findFirst().orElse(null);
-//                    if (temp != null) {
-//                        patentRight.setType(1);
+//                String[] strs = content.split("\n");
+//                while (matcherOut.find()) {
+//                    String matcherOutGroup = matcherOut.group().replace(".", "\\.");
+//                    contentOut = contentOut.replaceFirst(matcherOutGroup, "。\n" + matcherOutGroup.substring(matcherOutGroup.indexOf("。") + 1, matcherOutGroup.indexOf("\\")) + ".");
+//                }
+//                String[] strsOut = contentOut.split("\n");
+//                //定义父权要排序号
+//                String regex1 = "claim [0-9]+";
+//                String regex2 = "claims [0-9]+ or [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]);
+//                        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);
+//                                }
+//                            }
+//                            PatentRight patentRight = new PatentRight()
+//                                    .setPatentId(params.getPatentId())
+//                                    .setType(0)
+//                                    .setContent(strs[i])
+//                                    .setSort(i)
+//                                    .setParentSort(builder + "");
+//                            if (strsOut.length - 1 >= i) {
+//                                patentRight.setContentOut(strsOut[i]);
+//                            }
+//                            patentRights.add(patentRight);
+//                        } else if (matcher1.find()) {
+//                            String parentNum = matcher1.group().substring(matcher1.group().indexOf("m") + 2);
+//                            PatentRight patentRight = new PatentRight()
+//                                    .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 {
+//                        PatentRight patentRight = new PatentRight()
+//                                .setPatentId(params.getPatentId())
+//                                .setType(1)
+//                                .setContent(strs[i])
+//                                .setSort(i)
+//                                .setParentSort("-1");
+//                        if (strsOut.length - 1 >= i) {
+//                            patentRight.setContentOut(strsOut[i]);
+//                        }
+//                        patentRights.add(patentRight);
 //                    }
 //                }
-            ArrayList<PatentRight> patentRights = new ArrayList<>();
-            //先去掉所有换行符，使所有内容连起来
-            if (content.contains("\r\n")) {
-                content = content.replaceAll("\r\n", "");
-            } else {
-                content = content.replaceAll("\n", "");
-            }
-            if (contentOut == null) {
-                contentOut = "";
-            }
-            if (contentOut.contains("\r\n")) {
-                contentOut = contentOut.replaceAll("\r\n", "");
-            } else {
-                contentOut = contentOut.replaceAll("\n", "");
-            }
-            //去掉译文的所有空格
-            contentOut = contentOut.replaceAll(" +", "");
-
-            //中文专利的权要拆分 ↓
-            if (country.equals("CN") || country.equals("JP") || country.equals("KR")) {
-                String regex;
-                if (content.contains("。2.")) {
-                    regex = "。[0-9]+\\.";
-                } else if (content.contains("。2、")) {
-                    regex = "。[0-9]+[、]";
-                } else if (content.contains("[001]")) {
-                    regex = "\\[[0-9]+]";
-                } else if (content.contains("請求項")) {
-                    regex = "。【請求項[0-9]+】";
-                } else if (content.contains("청구항")) {
-                    regex = "\\.청구항 [0-9]+";
-                } else {
-                    regex = "";
-                }
-                Matcher matcher = Pattern.compile(regex).matcher(content);
-                Matcher matcherOut = Pattern.compile(regex).matcher(contentOut);
-                while (matcher.find()) {
-                    if (matcher.group().contains("청구항")) {
-                        String matcherGroup = matcher.group().replace(".", "\\.");
-                        content = content.replaceFirst(matcherGroup, ".\n" + matcherGroup.substring(matcherGroup.indexOf(".") + 1));
-                    } else if (matcher.group().contains(".")) {
-                        String matcherGroup = matcher.group().replace(".", "\\.");
-                        content = content.replaceFirst(matcherGroup, "。\n" + matcherGroup.substring(matcherGroup.indexOf("。") + 1, matcherGroup.indexOf("\\")) + ".");
-                    } else if (matcher.group().contains("、") || matcher.group().contains("請求項")) {
-                        content = content.replaceFirst(matcher.group(), "。\n" + matcher.group().substring(matcher.group().indexOf("。") + 1));
-                    }
-                }
-                String[] strs = content.split("\n");
-                while (matcherOut.find()) {
-                    if (matcherOut.group().contains(".")) {
-                        String matcherOutGroup = matcherOut.group().replace(".", "\\.");
-                        contentOut = contentOut.replaceFirst(matcherOutGroup, "。\n" + matcherOutGroup.substring(matcherOutGroup.indexOf("。") + 1, matcherOutGroup.indexOf("\\")) + ".");
-                    } else if (matcherOut.group().contains("、")) {
-                        contentOut = contentOut.replaceFirst(matcherOut.group(), "。\n" + matcherOut.group().substring(matcherOut.group().indexOf("。") + 1));
-                    }
-                }
-                String[] 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("权利要求")) {
-                        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);
-                                }
-                            }
-                            PatentRight patentRight = new PatentRight()
-                                    .setPatentId(params.getPatentId())
-                                    .setType(0)
-                                    .setContent(strs[i])
-                                    .setSort(i)
-                                    .setParentSort(builder + "");
-                            if (strsOut.length - 1 >= i) {
-                                patentRight.setContentOut(strsOut[i]);
-                            }
-                            patentRights.add(patentRight);
-                        } else if (matcher1.find()) {
-                            String parentNum = matcher1.group().substring(matcher1.group().indexOf("求") + 1);
-                            PatentRight patentRight = new PatentRight()
-                                    .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 {
-                        PatentRight patentRight = new PatentRight()
-                                .setPatentId(params.getPatentId())
-                                .setType(1)
-                                .setContent(strs[i])
-                                .setSort(i)
-                                .setParentSort("-1");
-                        if (strsOut.length - 1 >= i) {
-                            patentRight.setContentOut(strsOut[i]);
-                        }
-                        patentRights.add(patentRight);
-                    }
-                }
-
-                //英文专利的权要拆分 ↓
-            } else {
-                content = content.substring(content.indexOf("1."));
-                 if(contentOut.indexOf("1.")>-1){
-                     contentOut = contentOut.substring(contentOut.indexOf("1."));
-                 }
-               else{
-                     contentOut = contentOut.substring(contentOut.indexOf("1、"));
-                 }
-                String regex;
-                if (content.contains("1.")) {
-                    regex = "\\.[0-9]+\\. ";
-                }
-                else if (content.contains("1、")) {
-                    regex = "\\.[0-9]+\\. ";
-                }
-                else if (content.contains("[001]")) {
-                    regex = "\\[[0-9]+]";
-                }
-                else {
-                    regex = "";
-                }
-                Matcher matcher = Pattern.compile(regex).matcher(content);
-                Matcher matcherOut = Pattern.compile("。[0-9]+\\.").matcher(contentOut);
-                while (matcher.find()) {
-                    String matcherGroup = matcher.group().replace(".", "\\.");
-                    content = content.replaceFirst(matcherGroup, ".\n" + matcherGroup.substring(matcherGroup.indexOf(".") + 1, matcherGroup.lastIndexOf("\\")) + ". ");
-                }
-                String[] strs = content.split("\n");
-                while (matcherOut.find()) {
-                    String matcherOutGroup = matcherOut.group().replace(".", "\\.");
-                    contentOut = contentOut.replaceFirst(matcherOutGroup, "。\n" + matcherOutGroup.substring(matcherOutGroup.indexOf("。") + 1, matcherOutGroup.indexOf("\\")) + ".");
-                }
-                String[] strsOut = contentOut.split("\n");
-                //定义父权要排序号
-                String regex1 = "claim [0-9]+";
-                String regex2 = "claims [0-9]+ or [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]);
-                        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);
-                                }
-                            }
-                            PatentRight patentRight = new PatentRight()
-                                    .setPatentId(params.getPatentId())
-                                    .setType(0)
-                                    .setContent(strs[i])
-                                    .setSort(i)
-                                    .setParentSort(builder + "");
-                            if (strsOut.length - 1 >= i) {
-                                patentRight.setContentOut(strsOut[i]);
-                            }
-                            patentRights.add(patentRight);
-                        } else if (matcher1.find()) {
-                            String parentNum = matcher1.group().substring(matcher1.group().indexOf("m") + 2);
-                            PatentRight patentRight = new PatentRight()
-                                    .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 {
-                        PatentRight patentRight = new PatentRight()
-                                .setPatentId(params.getPatentId())
-                                .setType(1)
-                                .setContent(strs[i])
-                                .setSort(i)
-                                .setParentSort("-1");
-                        if (strsOut.length - 1 >= i) {
-                            patentRight.setContentOut(strsOut[i]);
-                        }
-                        patentRights.add(patentRight);
-                    }
-                }
-            }
-
-            this.saveOrUpdateBatch(patentRights);
-        }
+//            }
+//
+//            this.saveOrUpdateBatch(patentRights);
+//        }
     }
 
 

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

@@ -37,6 +37,7 @@ import java.util.stream.Collectors;
 @RequiredArgsConstructor(onConstructor_ = {@Lazy})
 public class ProjectUserService extends ServiceImpl<ProjectUserMapper, ProjectUser> {
     private final OAuth2Service oAuth2Service;
+
     public ProjectUser getProjectUserByProjectIdAndUserId(Integer projectId, Integer userId) {
         LambdaQueryWrapper<ProjectUser> queryWrapper = new LambdaQueryWrapper<>();
         queryWrapper.eq(ProjectUser::getProjectId, projectId);
@@ -53,6 +54,7 @@ public class ProjectUserService extends ServiceImpl<ProjectUserMapper, ProjectUs
     public List<Integer> getProIdByUserId(Integer userId) {
         return this.getProjectUserByUserId(userId).stream().map(ProjectUser::getProjectId).collect(Collectors.toList());
     }
+
     public List<Integer> getProjectUserIdByProjectId(Integer projectId) {
         LambdaQueryWrapper<ProjectUser> queryWrapper = new LambdaQueryWrapper<>();
         queryWrapper.eq(ProjectUser::getProjectId, projectId);
@@ -68,42 +70,42 @@ public class ProjectUserService extends ServiceImpl<ProjectUserMapper, ProjectUs
 
     public IPage<ProjectUser> getPageList(ProjectUserVO params) throws IOException {
         //根据专题库id和类型获得人员id
-        LambdaQueryWrapper<ProjectUser> wrapper =new LambdaQueryWrapper<>();
-        wrapper.eq(ProjectUser::getProjectId,params.getProjectId());
-        if(params.getType()!=null){
-            wrapper.eq(ProjectUser::getType,params.getType());
+        LambdaQueryWrapper<ProjectUser> wrapper = new LambdaQueryWrapper<>();
+        wrapper.eq(ProjectUser::getProjectId, params.getProjectId());
+        if (params.getType() != null) {
+            wrapper.eq(ProjectUser::getType, params.getType());
         }
-        List<ProjectUser> projectUserList =this.list(wrapper);
+        List<ProjectUser> projectUserList = this.list(wrapper);
 
-        List<Integer> userIds =projectUserList.stream().map(ProjectUser::getUserId).collect(Collectors.toList());
-        if(userIds.size()==0)
-        {IPage<ProjectUser> tem =new Page<>();
+        List<Integer> userIds = projectUserList.stream().map(ProjectUser::getUserId).collect(Collectors.toList());
+        if (userIds.size() == 0) {
+            IPage<ProjectUser> tem = new Page<>();
             tem.setSize(10);
             tem.setTotal(0);
             return tem;
         }
-        PasUserDTO pasUserDTO =new PasUserDTO();
+        PasUserDTO pasUserDTO = new PasUserDTO();
         pasUserDTO.setUserIds(userIds);
         pasUserDTO.setUsername(params.getUsername());
         pasUserDTO.setName(params.getName());
         pasUserDTO.setCurrent(params.getCurrent());
         pasUserDTO.setSize(params.getSize());
         String res = oAuth2Service.getPASAssignedUser(pasUserDTO);
-        JSONObject jsonObject =JSONObject.parseObject(res);
+        JSONObject jsonObject = JSONObject.parseObject(res);
         IPage<ProjectUser> pageList = new Page<>();
         pageList.setTotal(Integer.parseInt(jsonObject.get("total").toString()));
         pageList.setSize(Integer.parseInt(jsonObject.get("size").toString()));
-        List<PasUserVO>  records = JSONArray.parseArray(jsonObject.get("records").toString(),PasUserVO.class);
-       List<ProjectUser> list =new ArrayList<>();
-        for (PasUserVO item:records){
-            ProjectUser projectUser =  projectUserList.stream().filter(tem->tem.getUserId().equals(item.getId())).findFirst().orElse(new ProjectUser());
+        List<PasUserVO> records = JSONArray.parseArray(jsonObject.get("records").toString(), PasUserVO.class);
+        List<ProjectUser> list = new ArrayList<>();
+        for (PasUserVO item : records) {
+            ProjectUser projectUser = projectUserList.stream().filter(tem -> tem.getUserId().equals(item.getId())).findFirst().orElse(new ProjectUser());
             projectUser.setName(item.getName());
             projectUser.setUsername(item.getUsername());
             list.add(projectUser);
         }
         //根据
         //根据人员姓名，id，账号，分页信息查询人员
-       pageList.setRecords(list);
+        pageList.setRecords(list);
         return pageList;
     }
 

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

@@ -19,6 +19,7 @@ import cn.dev33.satoken.stp.StpUtil;
 import cn.hutool.core.io.FileUtil;
 import com.alibaba.fastjson.JSON;
 import com.alibaba.fastjson.JSONArray;
+import com.alibaba.fastjson.JSONObject;
 import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
 import com.baomidou.mybatisplus.core.metadata.IPage;
 import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
@@ -30,6 +31,7 @@ import org.springframework.stereotype.Service;
 import java.io.IOException;
 import java.util.ArrayList;
 import java.util.Arrays;
+import java.util.Collections;
 import java.util.List;
 import java.util.stream.Collectors;
 
@@ -43,24 +45,25 @@ import java.util.stream.Collectors;
  */
 @Service
 @RequiredArgsConstructor(onConstructor_ = {@Lazy})
-public class TaskService extends ServiceImpl<TaskMapper,Task> {
-
+public class TaskService extends ServiceImpl<TaskMapper, Task> {
     private final FileUtils fileUtils;
     private final LoginUtils loginUtils;
     private final RequestService requestService;
+    private final OutInterfaceService outInterfaceService;
+
     public String getFileUrl(Integer id) {
         Task task = this.getById(id);
         return fileUtils.getSystemPath() + task.getUrl();
     }
 
-    public Integer add(UploadFileDTO fileDTO, Integer projectId,Integer productId, Integer total, Integer type, Integer fieldNum, String oldName) {
+    public Integer add(UploadFileDTO fileDTO, Integer projectId, Integer productId, Integer total, Integer type, Integer fieldNum, String oldName) {
         Task task = new Task();
         task.setStartTime(DateUtils.getDateTime());
         task.setStatus(0);
-        if(projectId!=null) {
+        if (projectId != null) {
             task.setProjectId(projectId);
         }
-        if(productId!=null){
+        if (productId != null) {
             task.setProductId(productId);
         }
         task.setFileName(fileDTO.getFileName());
@@ -93,20 +96,36 @@ public class TaskService extends ServiceImpl<TaskMapper,Task> {
     }
 
     public IPage<Task> getPageList(TaskVO params) throws IOException {
+        String createName = params.getCreateName();
+        //如果此次查询是要根据创建人名称查询则👇
+        if (createName != null && !createName.equals("")) {
+            //远程调用权限系统的根据创建人名称模糊查询创建人ids的接口
+            String res = outInterfaceService.getPersonIdByNamePCS(createName);
+            List<Integer> createPersonIds = JSONArray.parseArray(res, Integer.class);
+            //当未查询到时给创建人ids集合赋值唯一元素id=-1，即查空页返回
+            if (createPersonIds == null || createPersonIds.size() == 0) {
+                createPersonIds = new ArrayList<>(Collections.singletonList(-1));
+            }
+            params.setCreatePersonIds(createPersonIds);
+        }
         IPage<Task> pageList = baseMapper.getPageList(new Page<>(params.getCurrent(), params.getSize()), params);
         this.setDataList(pageList.getRecords());
         return pageList;
     }
 
-    public List<Task> getQueueList(Integer type, Integer projectId,Integer productId) {
+    public List<Task> getQueueList(Integer type, Integer projectId, Integer productId) {
         LambdaQueryWrapper<Task> queryWrapper = new LambdaQueryWrapper<>();
         queryWrapper.eq(Task::getCreateBy, loginUtils.getId());
         queryWrapper.eq(Task::getType, type);
-        queryWrapper.in(Task::getStatus, new ArrayList<Integer>() {{ add(0); add(1);}});
-        if(projectId!=null){
-        queryWrapper.eq(Task::getProjectId, projectId);}
-        if(productId!=null){
-            queryWrapper.eq(Task::getProductId,productId);
+        queryWrapper.in(Task::getStatus, new ArrayList<Integer>() {{
+            add(0);
+            add(1);
+        }});
+        if (projectId != null) {
+            queryWrapper.eq(Task::getProjectId, projectId);
+        }
+        if (productId != null) {
+            queryWrapper.eq(Task::getProductId, productId);
         }
         queryWrapper.orderByAsc(Task::getStartTime);
         return this.list(queryWrapper);
@@ -145,7 +164,7 @@ public class TaskService extends ServiceImpl<TaskMapper,Task> {
 
     private void setDataList(List<Task> taskList) throws IOException {
         //获得创建人的id集合
-        List<Integer> createIds =taskList.stream().map(Task::getCreateBy).collect(Collectors.toList());
+        List<Integer> createIds = taskList.stream().map(Task::getCreateBy).collect(Collectors.toList());
         //获取专题库负责人对应信息
         String jsonObject1 = requestService.getPersonnelFromPCS(createIds);
         JSONArray jsonArray = JSON.parseArray(jsonObject1);
@@ -153,7 +172,7 @@ public class TaskService extends ServiceImpl<TaskMapper,Task> {
         for (Task task : taskList) {
             for (ProjectVO.Personnel personnel : personnelList) {
                 //装载创建人名
-                if(task.getCreateBy()!=null){
+                if (task.getCreateBy() != null) {
                     if (task.getCreateBy().equals(personnel.getId())) {
                         task.setCreateName(personnel.getPersonnelName());
                     }

PAS/src/main/resources/application-dev.yml

@@ -23,4 +23,5 @@ spring:
         login-password: Cslg2022+
       web-stat-filter:
         exclusions: "*.js,*.gif,*.jpg,*.png,*.css,*.ico,/druid/*"
-authorUrl: http://localhost:8871
+authorUrl: http://localhost:8871
+PCSUrl: http://localhost:8871

PAS/src/main/resources/mapper/TaskMapper.xml

@@ -4,14 +4,10 @@
     <select id="getPageList" parameterType="cn.cslg.pas.common.model.vo.TaskVO" resultType="cn.cslg.pas.domain.Task">
         select a.id, a.type, a.uid as create_by, a.ctime as start_time, a.tid as project_id,
         a.mfields as field_num, a.mun as total, a.endtime as end_time, a.status, a.filename as file_name,
-        a.filesize as file_size, a.downexcel as url, b.name as create_name, c.name as project_name, a.old_name
+        a.filesize as file_size, a.downexcel as url, c.name as project_name, a.old_name
         from os_task a
-        left join os_distribution b on a.uid = b.id
         left join os_thematic c on c.id = a.tid
         <where>
-            <if test="params.createName != '' and params.createName != null">
-                and b.name like concat('%', #{params.createName}, '%')
-            </if>
             <if test="params.status != null">
                 and a.status = #{params.status}
             </if>
@@ -27,6 +23,12 @@
             <if test="params.projectName != '' and params.projectName != null">
                 and c.name like concat('%', #{params.projectName}, '%')
             </if>
+            <if test="params.createPersonIds != null and params.createPersonIds.size > 0">
+                and a.uid in
+                <foreach collection="params.createPersonIds" item="n" separator="," open="(" close=")">
+                    #{n}
+                </foreach>
+            </if>
         </where>
         order by a.ctime ${params.order}
     </select>