Merge remote-tracking branch 'origin/master'

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

@@ -6,6 +6,7 @@ import lombok.Data;
 public class QueryExternalFamilyVO {
 
     private String patentNo;
+
     private Integer pageNum;
 
     private Integer pageSize;

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

@@ -405,11 +405,11 @@ public class EventService extends ServiceImpl<EventMapper, Event> implements Bus
             if (eventCountVOS.size() != 0) {
                 //专题库数量
                 EventCountVO eventCountVO1 = eventCountVOS.stream().filter(item ->
-                        item.getEventId().equals(eventVO.getId()) && item.getProjectType().equals(1)).findFirst().orElse(null);
+                        item.getEventId().equals(eventVO.getId()) && item.getProjectType().equals(0)).findFirst().orElse(null);
 
                 //报告数量
                 EventCountVO eventCountVO2 = eventCountVOS.stream().filter(item ->
-                        item.getEventId().equals(eventVO.getId()) && item.getProjectType().equals(2)).findFirst().orElse(null);
+                        item.getEventId().equals(eventVO.getId()) && item.getProjectType().equals(1)).findFirst().orElse(null);
 
                 //设置专题库数量
                 if (eventCountVO1 != null) {

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

@@ -86,6 +86,12 @@ public class MergePersonService extends ServiceImpl<MergePersonMapper, MergePers
     @Autowired
     private SystemDictMapper systemDictMapper;
 
+    /**
+     * 专利列表上新增发明人/权利人/申请人合并
+     * @param vo
+     * @return
+     * @throws Exception
+     */
     @Transactional(propagation = Propagation.REQUIRED, rollbackFor = Throwable.class)
     public Integer mergePerson(MergePersonVO vo) throws Exception {
         Integer type = vo.getType();
@@ -183,7 +189,7 @@ public class MergePersonService extends ServiceImpl<MergePersonMapper, MergePers
                                 Patent newPatent = new Patent();
                                 PatentJoin patentJoin = new PatentJoin();
                                 patentJoin.setParent(id);
-                                patentJoin.setName("merge_applicant");
+                                patentJoin.setName("merge_applicat");
                                 newPatent.setPatentJoin(patentJoin);
                                 newPatent.setMergeApplicant(appMergeList);
                                 String child = this.addChild(newPatent, id);
@@ -305,6 +311,12 @@ public class MergePersonService extends ServiceImpl<MergePersonMapper, MergePers
         return map;
     }
 
+    /**
+     * 专利列表上再次新增发明人/权利人/申请人合并
+     * @param vo
+     * @return
+     * @throws Exception
+     */
     @Transactional(propagation = Propagation.REQUIRED, rollbackFor = Throwable.class)
     public Integer mergePersonAgain(MergePersonAgainVO vo) throws Exception {
         List<String> mergedNames = vo.getNeedMergedName();
@@ -343,6 +355,12 @@ public class MergePersonService extends ServiceImpl<MergePersonMapper, MergePers
         return this.mergePerson(personVO);
     }
 
+    /**
+     * 专利列表上编辑发明人/权利人/申请人合并
+     * @param vo
+     * @return
+     * @throws Exception
+     */
     @Transactional(propagation = Propagation.REQUIRED, rollbackFor = Throwable.class)
     public Integer updateMergePerson(MergePersonVO vo) throws Exception {
         //获取登陆人信息 用于设置创建人
@@ -448,6 +466,11 @@ public class MergePersonService extends ServiceImpl<MergePersonMapper, MergePers
         return person.getId();
     }
 
+    /**
+     * 发明人/权利人/申请人合并列表查询
+     * @param vo
+     * @return
+     */
     public Records selectMergePersonList(MergePersonQueryVO vo) {
         List<MergePersonQueryDTO> list = new ArrayList<>();
         IPage<MergePerson> page = new Page<>(vo.getPageNum(), vo.getPageSize());
@@ -481,6 +504,11 @@ public class MergePersonService extends ServiceImpl<MergePersonMapper, MergePers
         return records;
     }
 
+    /**
+     * 合并人员详情
+     * @param vo
+     * @return
+     */
     public MergePersonQueryDTO selectMergePersonDetail(MergePersonIdVO vo) {
         MergePersonQueryDTO dto = new MergePersonQueryDTO();
         MergePerson person = mergePersonMapper.selectById(vo.getId());
@@ -492,6 +520,12 @@ public class MergePersonService extends ServiceImpl<MergePersonMapper, MergePers
         return dto;
     }
 
+    /**
+     * 获取所有发明人/权利人/申请人
+     * @param vo
+     * @return
+     * @throws Exception
+     */
     public Records getMergePerson(GetAllPersonVO vo) throws Exception {
         Integer projectId = vo.getProjectId();
         Long pageNum = vo.getPageNum();
@@ -739,8 +773,14 @@ public class MergePersonService extends ServiceImpl<MergePersonMapper, MergePers
         return records;
     }
 
+    /**
+     * 发明人/权利人/申请人合并后的名称移除
+     * @param vo
+     * @return
+     * @throws Exception
+     */
     @Transactional(propagation = Propagation.REQUIRED, rollbackFor = Throwable.class)
-    public Integer delMergedName(MergedNameVO vo) throws IOException {
+    public Integer delMergedName(MergedNameVO vo) throws Exception {
         Integer type = vo.getType();
         //要移除的名字
         String delName = vo.getDelName();
@@ -768,16 +808,27 @@ public class MergePersonService extends ServiceImpl<MergePersonMapper, MergePers
             builder.index("patent");
             List<Query> queries = new ArrayList<>();
             if (type == 0) {
-                Query q1 = QueryBuilders.term(i -> i.field("applicant.name.key").value(delName));
-                Query query1 = QueryBuilders.nested(i -> i.path("merge_applicat").query(q1));
-                Query q2 = QueryBuilders.term(i -> i.field("right_holder.name.key").value(delName));
-                Query query2 = QueryBuilders.nested(i -> i.path("right_holder").query(q2));
-                queries.add(query1);
-                queries.add(query2);
+                //合并申请人
+                Query idQ1 = QueryBuilders.term(i -> i.field("merge_applicant.project_id").value(projectId));
+                Query q1 = QueryBuilders.term(i -> i.field("merge_applicant.name.raw").value(name));
+                Query bool = QueryBuilders.bool(i -> i.must(idQ1, q1));
+                Query query1 = QueryBuilders.nested(i -> i.path("merge_applicant").query(bool));
+                Query childQ1 = QueryBuilders.hasChild(i -> i.type("merge_applicat").query(query1));
+                //合并权利人
+                Query idQ2 = QueryBuilders.term(i -> i.field("merge_right_holder.project_id").value(projectId));
+                Query q2 = QueryBuilders.term(i -> i.field("merge_right_holder.name.raw").value(name));
+                Query bool1 = QueryBuilders.bool(i -> i.must(idQ2, q2));
+                Query query2 = QueryBuilders.nested(i -> i.path("merge_right_holder").query(bool1));
+                Query childQ2 = QueryBuilders.hasChild(i -> i.type("merge_right_holder").query(query2));
+                queries.add(childQ1);
+                queries.add(childQ2);
             } else {
-                Query q = QueryBuilders.term(i -> i.field("inventor.name.key").value(delName));
-                Query query = QueryBuilders.nested(i -> i.path("inventor").query(q));
-                queries.add(query);
+                Query idQ = QueryBuilders.term(i -> i.field("merge_inventor.project_id").value(projectId));
+                Query q = QueryBuilders.term(i -> i.field("merge_inventor.name.raw").value(name));
+                Query bool = QueryBuilders.bool(i -> i.must(idQ, q));
+                Query query = QueryBuilders.nested(i -> i.path("merge_inventor").query(bool));
+                Query childQ = QueryBuilders.hasChild(i -> i.type("merge_inventor").query(query));
+                queries.add(childQ);
             }
             Query query = QueryBuilders.bool(i -> i.should(queries));
             builder.query(query);
@@ -796,35 +847,53 @@ public class MergePersonService extends ServiceImpl<MergePersonMapper, MergePers
                     if (type == 0) {
                         if (!CollectionUtils.isEmpty(patent.getApplicant())) {
                             List<PatentPerson> applicant = patent.getApplicant();
-                            for (PatentPerson patentPerson : applicant) {
-                                PatentMergePerson merge = new PatentMergePerson();
-                                merge.setName(delName);
-                                merge.setType(patentPerson.getType());
-                                merge.setOrder(patentPerson.getOrder());
-                                merge.setProjectId(String.valueOf(projectId));
-                                mergePersonList.add(merge);
+                            List<String> collect = applicant.stream().map(PatentPerson::getName).collect(Collectors.toList());
+                            if (collect.contains(delName)) {
+                                for (PatentPerson patentPerson : applicant) {
+                                    if (delName.equals(patentPerson.getName())) {
+                                        PatentMergePerson merge = new PatentMergePerson();
+                                        merge.setName(delName);
+                                        merge.setType(patentPerson.getType());
+                                        merge.setOrder(patentPerson.getOrder());
+                                        merge.setProjectId(String.valueOf(projectId));
+                                        mergePersonList.add(merge);
+                                    }
+                                }
                             }
+
                         }
-                        if (CollectionUtils.isEmpty(mergePersonList)) {
+                        if (CollectionUtils.isEmpty(mergePersonList) && !CollectionUtils.isEmpty(patent.getRightHolder())) {
                             List<PatentPerson> rightHolder = patent.getRightHolder();
-                            for (PatentPerson patentPerson : rightHolder) {
-                                PatentMergePerson merge = new PatentMergePerson();
-                                merge.setName(delName);
-                                merge.setType(patentPerson.getType());
-                                merge.setOrder(patentPerson.getOrder());
-                                merge.setProjectId(String.valueOf(projectId));
-                                mergePersonList.add(merge);
+                            List<String> collect = rightHolder.stream().map(PatentPerson::getName).collect(Collectors.toList());
+                            if (collect.contains(delName)) {
+                                for (PatentPerson patentPerson : rightHolder) {
+                                    if (delName.equals(patentPerson.getName())) {
+                                        PatentMergePerson merge = new PatentMergePerson();
+                                        merge.setName(delName);
+                                        merge.setType(patentPerson.getType());
+                                        merge.setOrder(patentPerson.getOrder());
+                                        merge.setProjectId(String.valueOf(projectId));
+                                        mergePersonList.add(merge);
+                                    }
+                                }
                             }
                         }
                     } else {
-                        List<PatentPerson> inventor = patent.getInventor();
-                        for (PatentPerson patentPerson : inventor) {
-                            PatentMergePerson merge = new PatentMergePerson();
-                            merge.setName(delName);
-                            merge.setType(patentPerson.getType());
-                            merge.setOrder(patentPerson.getOrder());
-                            merge.setProjectId(String.valueOf(projectId));
-                            mergePersonList.add(merge);
+                        if (!CollectionUtils.isEmpty(patent.getInventor())) {
+                            List<PatentPerson> inventor = patent.getInventor();
+                            List<String> collect = inventor.stream().map(PatentPerson::getName).collect(Collectors.toList());
+                            if (collect.contains(delName)) {
+                                for (PatentPerson patentPerson : inventor) {
+                                    if (delName.equals(patentPerson.getName())) {
+                                        PatentMergePerson merge = new PatentMergePerson();
+                                        merge.setName(delName);
+                                        merge.setType(patentPerson.getType());
+                                        merge.setOrder(patentPerson.getOrder());
+                                        merge.setProjectId(String.valueOf(projectId));
+                                        mergePersonList.add(merge);
+                                    }
+                                }
+                            }
                         }
                     }
 
@@ -833,46 +902,84 @@ public class MergePersonService extends ServiceImpl<MergePersonMapper, MergePers
                         Map<String, List<PatentMergePerson>> appMap = this.getChildMergePerson(id, projectId, "merge_applicant");
                         if (!CollectionUtils.isEmpty(appMap)) {
                             for (String appId : appMap.keySet()) {
-                                List<PatentMergePerson> appList = appMap.get(appId);
-                                List<String> collect = appList.stream().map(PatentMergePerson::getName).collect(Collectors.toList());
-                                if (collect.contains(name)) {
-                                    this.add(appId, type, mergePersonList);
-                                }
                                 if (CollectionUtils.isEmpty(nameDatas)) {
                                     this.delSingleMerge(appId, type, name);
                                 }
+
+                                List<PatentMergePerson> appMergeList = new ArrayList<>(mergePersonList);
+                                List<PatentMergePerson> appList = appMap.get(appId);
+                                appMergeList.addAll(appList);
+                                //添加子文档
+                                Patent newPatent = new Patent();
+                                PatentJoin patentJoin = new PatentJoin();
+                                patentJoin.setParent(id);
+                                patentJoin.setName("merge_applicat");
+                                newPatent.setPatentJoin(patentJoin);
+                                newPatent.setMergeApplicant(appMergeList);
+                                String child = this.addChild(newPatent, id);
+                                if (StringUtils.isEmpty(child)) {
+                                    throw new XiaoShiException("移除失败");
+                                } else {
+                                    //删除原子文档
+                                    this.delete(Arrays.asList(appId));
+                                }
                             }
                         }
                         //权利人
                         Map<String, List<PatentMergePerson>> rightMap = this.getChildMergePerson(id, projectId, "merge_right_holder");
                         if (!CollectionUtils.isEmpty(rightMap)) {
                             for (String rightId : rightMap.keySet()) {
-                                List<PatentMergePerson> rightList = rightMap.get(rightId);
-                                List<String> collect = rightList.stream().map(PatentMergePerson::getName).collect(Collectors.toList());
-                                if (collect.contains(name)) {
-                                    this.add(rightId, type, mergePersonList);
-                                }
                                 if (CollectionUtils.isEmpty(nameDatas)) {
                                     this.delSingleMerge(rightId, type, name);
                                 }
+
+                                ArrayList<PatentMergePerson> rightMergeList = new ArrayList<>(mergePersonList);
+                                List<PatentMergePerson> rightList = rightMap.get(rightId);
+                                rightMergeList.addAll(rightList);
+                                //添加子文档
+                                Patent newPatent = new Patent();
+                                PatentJoin patentJoin = new PatentJoin();
+                                patentJoin.setParent(id);
+                                patentJoin.setName("merge_right_holder");
+                                newPatent.setPatentJoin(patentJoin);
+                                newPatent.setMergeRightHolder(rightMergeList);
+                                String child = this.addChild(newPatent, id);
+                                if (StringUtils.isEmpty(child)) {
+                                    throw new XiaoShiException("移除失败");
+                                } else {
+                                    //删除原子文档
+                                    this.delete(Arrays.asList(rightId));
+                                }
                             }
                         }
                     } else if (type == 2) {
                         Map<String, List<PatentMergePerson>> inventorMap = this.getChildMergePerson(id, projectId, "merge_inventor");
                         if (!CollectionUtils.isEmpty(inventorMap)) {
                             for (String inventorId : inventorMap.keySet()) {
-                                List<PatentMergePerson> inventorList = inventorMap.get(inventorId);
-                                List<String> collect = inventorList.stream().map(PatentMergePerson::getName).collect(Collectors.toList());
-                                if (collect.contains(name)) {
-                                    this.add(inventorId, type, mergePersonList);
-                                }
                                 if (CollectionUtils.isEmpty(nameDatas)) {
                                     this.delSingleMerge(inventorId, type, mergedName);
                                 }
+
+                                ArrayList<PatentMergePerson> inventorMergeList = new ArrayList<>(mergePersonList);
+                                List<PatentMergePerson> inventorList = inventorMap.get(inventorId);
+                                inventorMergeList.addAll(inventorList);
+                                //添加子文档
+                                Patent newPatent = new Patent();
+                                PatentJoin patentJoin = new PatentJoin();
+                                patentJoin.setParent(id);
+                                patentJoin.setName("merge_inventor");
+                                newPatent.setPatentJoin(patentJoin);
+                                newPatent.setMergeInventor(inventorMergeList);
+                                String child = this.addChild(newPatent, id);
+                                if (StringUtils.isEmpty(child)) {
+                                    throw new XiaoShiException("移除失败");
+                                } else {
+                                    //删除原子文档
+                                    this.delete(Arrays.asList(inventorId));
+                                }
                             }
                         }
                     }
-
                 }
             } else {
                 throw new XiaoShiException("移除失败");
@@ -881,12 +988,21 @@ public class MergePersonService extends ServiceImpl<MergePersonMapper, MergePers
         return mergePerson.getId();
     }
 
+    /**
+     * 发明人/权利人/申请人合并记录删除
+     * @param vo
+     * @return
+     * @throws Exception
+     */
     @Transactional(propagation = Propagation.REQUIRED, rollbackFor = Throwable.class)
-    public Integer delMergePerson(MergePersonIdVO vo) throws IOException {
+    public Integer delMergePerson(MergePersonIdVO vo) throws Exception {
         Integer type = vo.getType();
         MergePerson mergePerson = mergePersonMapper.selectById(vo.getId());
+        //合并后的名称
         String name = mergePerson.getName();
+        //专题库id
         Integer projectId = mergePerson.getProjectId();
+        //合并的名称
         String mergedName = mergePerson.getMergedName();
         if (ObjectUtil.isNotEmpty(mergePerson)) {
             LambdaQueryWrapper<MergePerson> wrapper = new LambdaQueryWrapper<MergePerson>()
@@ -952,7 +1068,7 @@ public class MergePersonService extends ServiceImpl<MergePersonMapper, MergePers
 
                                 }
                             }
-                            if (CollectionUtils.isEmpty(mergePersonList)) {
+                            if (!CollectionUtils.isEmpty(patent.getRightHolder()) && list.size() != mergePersonList.size()) {
                                 List<PatentPerson> rightHolder = patent.getRightHolder();
                                 for (PatentPerson patentPerson : rightHolder) {
                                     if (list.contains(patentPerson.getName())) {
@@ -963,19 +1079,20 @@ public class MergePersonService extends ServiceImpl<MergePersonMapper, MergePers
                                         merge.setProjectId(String.valueOf(projectId));
                                         mergePersonList.add(merge);
                                     }
-
                                 }
                             }
                         } else {
-                            List<PatentPerson> inventor = patent.getInventor();
-                            for (PatentPerson patentPerson : inventor) {
-                                if (list.contains(patentPerson.getName())) {
-                                    PatentMergePerson merge = new PatentMergePerson();
-                                    merge.setName(patentPerson.getName());
-                                    merge.setType(patentPerson.getType());
-                                    merge.setOrder(patentPerson.getOrder());
-                                    merge.setProjectId(String.valueOf(projectId));
-                                    mergePersonList.add(merge);
+                            if (!CollectionUtils.isEmpty(patent.getInventor())) {
+                                List<PatentPerson> inventor = patent.getInventor();
+                                for (PatentPerson patentPerson : inventor) {
+                                    if (list.contains(patentPerson.getName())) {
+                                        PatentMergePerson merge = new PatentMergePerson();
+                                        merge.setName(patentPerson.getName());
+                                        merge.setType(patentPerson.getType());
+                                        merge.setOrder(patentPerson.getOrder());
+                                        merge.setProjectId(String.valueOf(projectId));
+                                        mergePersonList.add(merge);
+                                    }
                                 }
                             }
                         }
@@ -985,21 +1102,71 @@ public class MergePersonService extends ServiceImpl<MergePersonMapper, MergePers
                             Map<String, List<PatentMergePerson>> appMap = this.getChildMergePerson(id, projectId, "merge_applicant");
                             if (!CollectionUtils.isEmpty(appMap)) {
                                 for (String appId : appMap.keySet()) {
-                                    this.add(appId, type, mergePersonList);
+                                    List<PatentMergePerson> appMergeList = new ArrayList<>(mergePersonList);
+                                    List<PatentMergePerson> appList = appMap.get(appId);
+                                    appMergeList.addAll(appList);
+                                    //添加子文档
+                                    Patent newPatent = new Patent();
+                                    PatentJoin patentJoin = new PatentJoin();
+                                    patentJoin.setParent(id);
+                                    patentJoin.setName("merge_applicat");
+                                    newPatent.setPatentJoin(patentJoin);
+                                    newPatent.setMergeApplicant(appMergeList);
+                                    String child = this.addChild(newPatent, id);
+                                    if (StringUtils.isEmpty(child)) {
+                                        throw new XiaoShiException("删除失败");
+                                    } else {
+                                        //删除原子文档
+                                        this.delete(Arrays.asList(appId));
+                                    }
                                 }
                             }
+
+
                             //权利人
                             Map<String, List<PatentMergePerson>> rightMap = this.getChildMergePerson(id, projectId, "merge_right_holder");
                             if (!CollectionUtils.isEmpty(rightMap)) {
                                 for (String rightId : rightMap.keySet()) {
-                                    this.add(rightId, type, mergePersonList);
+                                    ArrayList<PatentMergePerson> rightMergeList = new ArrayList<>(mergePersonList);
+                                    List<PatentMergePerson> rightList = rightMap.get(rightId);
+                                    rightMergeList.addAll(rightList);
+                                    //添加子文档
+                                    Patent newPatent = new Patent();
+                                    PatentJoin patentJoin = new PatentJoin();
+                                    patentJoin.setParent(id);
+                                    patentJoin.setName("merge_right_holder");
+                                    newPatent.setPatentJoin(patentJoin);
+                                    newPatent.setMergeRightHolder(rightMergeList);
+                                    String child = this.addChild(newPatent, id);
+                                    if (StringUtils.isEmpty(child)) {
+                                        throw new XiaoShiException("删除失败");
+                                    } else {
+                                        //删除原子文档
+                                        this.delete(Arrays.asList(rightId));
+                                    }
                                 }
                             }
                         } else if (type == 2) {
                             Map<String, List<PatentMergePerson>> inventorMap = this.getChildMergePerson(id, projectId, "merge_inventor");
                             if (!CollectionUtils.isEmpty(inventorMap)) {
                                 for (String inventorId : inventorMap.keySet()) {
-                                    this.add(inventorId, type, mergePersonList);
+                                    ArrayList<PatentMergePerson> inventorMergeList = new ArrayList<>(mergePersonList);
+                                    List<PatentMergePerson> inventorList = inventorMap.get(inventorId);
+                                    inventorMergeList.addAll(inventorList);
+                                    //添加子文档
+                                    Patent newPatent = new Patent();
+                                    PatentJoin patentJoin = new PatentJoin();
+                                    patentJoin.setParent(id);
+                                    patentJoin.setName("merge_inventor");
+                                    newPatent.setPatentJoin(patentJoin);
+                                    newPatent.setMergeInventor(inventorMergeList);
+                                    String child = this.addChild(newPatent, id);
+                                    if (StringUtils.isEmpty(child)) {
+                                        throw new XiaoShiException("删除失败");
+                                    } else {
+                                        //删除原子文档
+                                        this.delete(Arrays.asList(inventorId));
+                                    }
                                 }
                             }
                         }

src/main/java/cn/cslg/pas/service/common/PatentStarApiService.java

@@ -837,7 +837,9 @@ public class PatentStarApiService {
             //装载公告号
             patentColumnDTO.setGrantNo(item.getPublicAccreditNo());
             //装载专利状态
-            patentColumnDTO.setSimpleStatus(item.getLG().toString());
+            if (item.getLG() != null) {
+                patentColumnDTO.setSimpleStatus(item.getLG().toString());
+            }
             //装载摘要
             List<Text> abstractList = new ArrayList<>();
             Text text = new Text();
@@ -990,9 +992,14 @@ public class PatentStarApiService {
      */
     public PatentColumnDTO queryExternalDetail(QueryExternalFamilyVO vo) throws IOException {
         PatentStarListDTO patentStarListDTO = new PatentStarListDTO();
-        String condition = "AN=" + vo.getPatentNo();
+        String condition = "AN=" + vo.getPatentNo() + " OR " + "PN=" + vo.getPatentNo();
         patentStarListDTO.setCurrentQuery(condition);
-        patentStarListDTO.setDBType("CN");
+        String index = vo.getPatentNo().substring(0, 2);
+        if (index.equals("CN")) {
+            patentStarListDTO.setDBType("CN");
+        } else {
+            patentStarListDTO.setDBType("WD");
+        }
         patentStarListDTO.setOrderBy("AD");
         patentStarListDTO.setOrderByType("DESC");
         patentStarListDTO.setPageNum(1);
@@ -1198,7 +1205,7 @@ public class PatentStarApiService {
         List<String> list = new ArrayList<>();
         List<LegalEvent> legalEvents = new ArrayList<>();
         String cnLegalApi = this.getCnLegalApi(appNo);
-        if (StringUtils.isNotEmpty(cnLegalApi)) {
+        if (StringUtils.isNotEmpty(cnLegalApi) && !cnLegalApi.equals("{}") && !cnLegalApi.contains("408")) {
             List<ExternalLegalStatusDTO> statusDTOS = JSONArray.parseArray(cnLegalApi, ExternalLegalStatusDTO.class);
             if (!CollectionUtils.isEmpty(statusDTOS)) {
                 List<ExternalLegalStatusDTO> statusList = statusDTOS.stream().sorted(Comparator.comparing(ExternalLegalStatusDTO::getLegalDate).reversed()).collect(Collectors.toList());
@@ -1220,6 +1227,7 @@ public class PatentStarApiService {
                 }
             }
         }
+
         infoDTO.setLegalStatus(list);
         infoDTO.setLegalEvents(legalEvents);
         return infoDTO;

src/main/resources/mapper/AssoProjectEvent.xml

@@ -2,18 +2,15 @@
 <!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd" >
 <mapper namespace="cn.cslg.pas.mapper.AssoProjectEventMapper">
     <select id="getEventProjectCount" resultType="cn.cslg.pas.common.vo.business.EventCountVO">
-        select event_id as eventId,project_type as projectType,count(*) as projectCount from
-        pas_prod2.asso_project_event
+        select event_id as eventId,project_type as projectType,count(*) as projectCount
+        from pas_prod2.asso_project_event
         <where>
             event_id in
-            <foreach collection="eventIds" index="index" item="item" open="(" separator=" or " close=")">
+            <foreach collection="eventIds" index="index" item="item" open="(" separator="," close=")">
                 #{item}
             </foreach>
             group by event_id,project_type
-
         </where>
-
-
     </select>
 
     <select id="getEventProjectNumOrder" resultType="java.lang.Integer">