合并相关接口

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

@@ -0,0 +1,13 @@
+package cn.cslg.pas.common.dto;
+
+import lombok.Data;
+
+@Data
+public class GetAllCountryDTO {
+
+    private String label;
+
+    private String value;
+
+    private String type;
+}

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

@@ -18,4 +18,7 @@ public class GetAllPersonDTO {
     //类型  0 申请人  1 权利人  2 发明人
     private Integer type;
 
+    //合并标识
+    private Integer mergeId;
+
 }

src/main/java/cn/cslg/pas/common/dto/patentCount/GetEsAllPersonDTO.java

@@ -14,10 +14,6 @@ public class GetEsAllPersonDTO {
 
     private List<String> inventor;
 
-    private String address;
-
-    private String country;
-
     private PersonAddress applicantAddr;
 
     private PersonAddress rightHolderAddr;

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

@@ -13,9 +13,9 @@ public class GetAllPersonVO {
 
     private String name;
 
-    private Integer pageNum;
+    private Long pageNum;
 
-    private Integer pageSize;
+    private Long pageSize;
 
     //类型  0 申请人  1 权利人  2 发明人
     private Integer type;

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

@@ -0,0 +1,29 @@
+package cn.cslg.pas.common.vo.business;
+
+import lombok.Data;
+
+import java.util.List;
+
+@Data
+public class MergePersonAgainVO {
+
+    private List<String> needMergedName;
+
+    private List<String> mergeName;
+
+    private Integer projectId;
+
+    private Integer type;
+
+    private String name;
+
+    private String abbreviation;
+
+    private String country;
+
+    private String province;
+
+    private String address;
+
+    private String remark;
+}

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

@@ -3,7 +3,7 @@ package cn.cslg.pas.common.vo.business;
 import lombok.Data;
 
 @Data
-public class   MergePersonIdVO {
+public class MergePersonIdVO {
 
     private Integer id;
 

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

@@ -1,12 +1,9 @@
 package cn.cslg.pas.controller;
 
 import cn.cslg.pas.common.core.base.Constants;
-import cn.cslg.pas.common.dto.InnerPatentPdfDTO;
-import cn.cslg.pas.common.dto.MergePersonQueryDTO;
-import cn.cslg.pas.common.dto.PatentColumnDTO;
+import cn.cslg.pas.common.dto.*;
 import cn.cslg.pas.common.dto.PatentExport.PatentExportParams;
 import cn.cslg.pas.common.dto.PatentExport.TaskParams;
-import cn.cslg.pas.common.dto.PatentKinDTO;
 import cn.cslg.pas.common.dto.business.EsCountDTO;
 import cn.cslg.pas.common.dto.business.SelectClaimDTO;
 import cn.cslg.pas.common.model.cronModel.Records;
@@ -161,6 +158,13 @@ public class PatentController {
         return Response.success(personId);
     }
 
+    @Operation(summary = "专利列表上再次新增发明人/权利人/申请人合并")
+    @PostMapping("/mergePersonAgain")
+    public Response mergePersonAgain(@RequestBody MergePersonAgainVO againVO) throws Exception {
+        Integer personId = mergePersonService.mergePersonAgain(againVO);
+        return Response.success(personId);
+    }
+
     @Operation(summary = "专利列表上编辑发明人/权利人/申请人合并")
     @PostMapping("/updateMergePerson")
     public Response updateMergePerson(@RequestBody MergePersonVO personVO) throws Exception{
@@ -203,6 +207,15 @@ public class PatentController {
         return Response.success(id);
     }
 
+    //-------------------------------获取所有国家-----------------
+    @Operation(summary = "获取所有国家列表查询")
+    @GetMapping("/getAllCountry")
+    public Response getAllCountry() {
+        List<GetAllCountryDTO> allCountry = mergePersonService.getAllCountry();
+        return Response.success(allCountry);
+    }
+
+    //--------------------导出-----------------------
     @PostMapping("/exportPDFFirstPage")
     @Operation(summary = "导出专利PDF")
     public ResponseEntity<InputStreamResource> exportPDFFirstPage(@RequestBody EsCustomFieldBatchVO EsVO) throws IOException {

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

@@ -1,5 +1,6 @@
 package cn.cslg.pas.service.business;
 
+import cn.cslg.pas.common.dto.GetAllCountryDTO;
 import cn.cslg.pas.common.dto.GetAllPersonDTO;
 import cn.cslg.pas.common.dto.MergePersonQueryDTO;
 import cn.cslg.pas.common.dto.PatentColumnDTO;
@@ -15,11 +16,14 @@ import cn.cslg.pas.common.vo.business.*;
 import cn.cslg.pas.domain.BaseEntity;
 import cn.cslg.pas.domain.business.FollowUp;
 import cn.cslg.pas.domain.business.MergePerson;
+import cn.cslg.pas.domain.business.SystemDict;
 import cn.cslg.pas.domain.es.Patent;
 import cn.cslg.pas.domain.es.PatentMergePerson;
+import cn.cslg.pas.domain.es.PatentPerson;
 import cn.cslg.pas.domain.es.PersonAddress;
 import cn.cslg.pas.exception.UnLoginException;
 import cn.cslg.pas.mapper.MergePersonMapper;
+import cn.cslg.pas.mapper.SystemDictMapper;
 import cn.cslg.pas.service.business.es.EsPatentService;
 import cn.cslg.pas.service.business.es.EsService;
 import cn.cslg.pas.service.query.FormatQueryService;
@@ -76,6 +80,8 @@ public class MergePersonService extends ServiceImpl<MergePersonMapper, MergePers
     private EsPatentService esPatentService;
     @Autowired
     private EsService esService;
+    @Autowired
+    private SystemDictMapper systemDictMapper;
 
     @Transactional(propagation = Propagation.REQUIRED, rollbackFor = Throwable.class)
     public Integer mergePerson(MergePersonVO vo) throws Exception {
@@ -146,10 +152,29 @@ public class MergePersonService extends ServiceImpl<MergePersonMapper, MergePers
 
             for (String id : map.keySet()) {
                 Patent patent = map.get(id);
-                List<PatentMergePerson> mergeApplicants = patent.getMergeApplicant();
-                mergePersonList.addAll(mergeApplicants);
-                patent.setMergeApplicant(mergePersonList);
-                patent.setMergeRightHolder(mergePersonList);
+                if (type == 0) {
+                    //申请人
+                    List<PatentMergePerson> mergeApplicants = new ArrayList<>();
+                    if (!CollectionUtils.isEmpty(patent.getMergeApplicant())) {
+                        mergeApplicants = patent.getMergeApplicant();
+                    }
+                    mergeApplicants.addAll(mergePersonList);
+                    //权利人
+                    List<PatentMergePerson> mergeRightHolder = new ArrayList<>();
+                    if (!CollectionUtils.isEmpty(patent.getMergeRightHolder())) {
+                        mergeRightHolder = patent.getMergeRightHolder();
+                    }
+                    mergeRightHolder.addAll(mergePersonList);
+                    patent.setMergeApplicant(mergeApplicants);
+                    patent.setMergeRightHolder(mergeRightHolder);
+                } else if (type == 2) {
+                    List<PatentMergePerson> mergeInventor = new ArrayList<>();
+                    if (!CollectionUtils.isEmpty(patent.getMergeInventor())) {
+                        mergeInventor = patent.getMergeInventor();
+                    }
+                    mergeInventor.addAll(mergePersonList);
+                    patent.setMergeInventor(mergeInventor);
+                }
                 esService.updateMergePerson(patent, id);
             }
         }
@@ -157,6 +182,44 @@ public class MergePersonService extends ServiceImpl<MergePersonMapper, MergePers
     }
 
     @Transactional(propagation = Propagation.REQUIRED, rollbackFor = Throwable.class)
+    public Integer mergePersonAgain(MergePersonAgainVO vo) throws Exception {
+        List<String> mergedNames = vo.getNeedMergedName();
+        List<String> mergeName = vo.getMergeName();
+        List<String> nameList = new ArrayList<>();
+        if (!CollectionUtils.isEmpty(mergedNames)) {
+            for (String mergedName : mergedNames) {
+                MergePerson person = mergePersonMapper.selectOne(new LambdaQueryWrapper<MergePerson>()
+                        .eq(MergePerson::getProjectId, vo.getProjectId())
+                        .eq(MergePerson::getName, mergedName));
+                String name = person.getMergedName();
+                List<String> getNames = JSONArray.parseArray(name, String.class);
+                nameList.addAll(getNames);
+
+                MergePersonIdVO personIdVO = new MergePersonIdVO();
+                personIdVO.setId(person.getId());
+                personIdVO.setType(person.getType());
+                this.delMergePerson(personIdVO);
+            }
+        }
+
+        if (!CollectionUtils.isEmpty(mergeName)) {
+            nameList.addAll(mergeName);
+        }
+
+        MergePersonVO personVO = new MergePersonVO();
+        personVO.setProjectId(vo.getProjectId());
+        personVO.setType(vo.getType());
+        personVO.setName(vo.getName());
+        personVO.setAbbreviation(vo.getAbbreviation());
+        personVO.setCountry(vo.getCountry());
+        personVO.setProvince(vo.getProvince());
+        personVO.setAddress(vo.getAddress());
+        personVO.setRemark(vo.getRemark());
+        personVO.setMergedName(nameList);
+        return this.mergePerson(personVO);
+    }
+
+    @Transactional(propagation = Propagation.REQUIRED, rollbackFor = Throwable.class)
     public Integer updateMergePerson(MergePersonVO vo) throws Exception {
         //获取登陆人信息 用于设置创建人
         PersonnelVO personnelVO = new PersonnelVO();
@@ -181,57 +244,92 @@ public class MergePersonService extends ServiceImpl<MergePersonMapper, MergePers
 
         if (ObjectUtil.isNotEmpty(person)) {
             BeanUtils.copyProperties(vo, person);
-            person.setMergedName(JSONArray.toJSONString(vo.getMergedName()));
+//            person.setMergedName(JSONArray.toJSONString(vo.getMergedName()));
             person.setCreateId(personnelVO.getId());
             person.setCreateTime(new Date());
             person.updateById();
 
-            List<String> mergedNames = JSONArray.parseArray(mergedName, String.class);
-            SearchRequest.Builder builder = new SearchRequest.Builder();
-            //设置查询索引
-            builder.index("patent");
+            if (!name.equals(vo.getName())) {
+                List<String> mergedNames = JSONArray.parseArray(mergedName, String.class);
+                SearchRequest.Builder builder = new SearchRequest.Builder();
+                //设置查询索引
+                builder.index("patent");
 
-            List<Query> queries = new ArrayList<>();
-            if (type == 0) {
-                for (String merged : mergedNames) {
-                    Query q1 = QueryBuilders.term(i -> i.field("applicant.name.key").value(merged));
-                    Query query1 = QueryBuilders.nested(i -> i.path("applicant").query(q1));
-                    Query q2 = QueryBuilders.term(i -> i.field("right_holder.name.key").value(merged));
-                    Query query2 = QueryBuilders.nested(i -> i.path("right_holder").query(q2));
-                    queries.add(query1);
-                    queries.add(query2);
+                List<Query> queries = new ArrayList<>();
+                if (type == 0) {
+                    for (String merged : mergedNames) {
+                        Query q1 = QueryBuilders.term(i -> i.field("applicant.name.key").value(merged));
+                        Query query1 = QueryBuilders.nested(i -> i.path("applicant").query(q1));
+                        Query q2 = QueryBuilders.term(i -> i.field("right_holder.name.key").value(merged));
+                        Query query2 = QueryBuilders.nested(i -> i.path("right_holder").query(q2));
+                        queries.add(query1);
+                        queries.add(query2);
+                    }
+                } else {
+                    for (String merged : mergedNames) {
+                        Query q = QueryBuilders.term(i -> i.field("inventor.name.key").value(merged));
+                        Query query = QueryBuilders.nested(i -> i.path("inventor").query(q));
+                        queries.add(query);
+                    }
                 }
-            } else {
-                for (String merged : mergedNames) {
-                    Query q = QueryBuilders.term(i -> i.field("inventor.name.key").value(merged));
-                    Query query = QueryBuilders.nested(i -> i.path("inventor").query(q));
-                    queries.add(query);
+                Query query = QueryBuilders.bool(i -> i.should(queries));
+                builder.query(query);
+                SearchResponse<Patent> response = client.search(builder.build(), Patent.class);
+                List<Hit<Patent>> hits = response.hits().hits();
+                Map<String, Patent> map = new HashMap<>();
+                for (Hit<Patent> hit : hits) {
+                    String id = hit.id();
+                    map.put(id, hit.source());
                 }
-            }
-            Query query = QueryBuilders.bool(i -> i.should(queries));
-            builder.query(query);
-            SearchResponse<Patent> response = client.search(builder.build(), Patent.class);
-            List<Hit<Patent>> hits = response.hits().hits();
-            Map<String, Patent> map = new HashMap<>();
-            for (Hit<Patent> hit : hits) {
-                String id = hit.id();
-                map.put(id, hit.source());
-            }
 
-            if (!CollectionUtils.isEmpty(map)) {
-                for (String id : map.keySet()) {
-                    Patent patent = map.get(id);
-                    List<PatentMergePerson> mergeApplicants = patent.getMergeApplicant();
-                    if (!name.equals(vo.getName())) {
-                        for (PatentMergePerson mergeApplicant : mergeApplicants) {
-                            if (mergeApplicant.getName().equals(name)) {
-                                mergeApplicant.setName(vo.getName());
+                if (!CollectionUtils.isEmpty(map)) {
+                    for (String id : map.keySet()) {
+                        Patent patent = map.get(id);
+                        if (type == 0) {
+                            //申请人
+                            List<PatentMergePerson> mergeApplicants = new ArrayList<>();
+                            if (!CollectionUtils.isEmpty(patent.getMergeApplicant())) {
+                                mergeApplicants = patent.getMergeApplicant();
+
+                                for (PatentMergePerson mergeApplicant : mergeApplicants) {
+                                    if (mergeApplicant.getName().equals(name)) {
+                                        mergeApplicant.setName(vo.getName());
+                                    }
+                                }
+
+                                patent.setMergeApplicant(mergeApplicants);
+                            }
+
+                            //权利人
+                            List<PatentMergePerson> mergeRightHolders = new ArrayList<>();
+                            if (!CollectionUtils.isEmpty(patent.getMergeRightHolder())) {
+                                mergeRightHolders = patent.getMergeRightHolder();
+                                for (PatentMergePerson mergeRightHolder : mergeRightHolders) {
+                                    if (mergeRightHolder.getName().equals(name)) {
+                                        mergeRightHolder.setName(vo.getName());
+                                    }
+                                }
+
+                                patent.setMergeRightHolder(mergeRightHolders);
+                            }
+
+                        } else if (type == 2) {
+                            List<PatentMergePerson> mergeInventors = new ArrayList<>();
+                            if (!CollectionUtils.isEmpty(patent.getMergeInventor())) {
+                                mergeInventors = patent.getMergeInventor();
+
+                                for (PatentMergePerson mergeInventor : mergeInventors) {
+                                    if (mergeInventor.getName().equals(name)) {
+                                        mergeInventor.setName(vo.getName());
+                                    }
+                                }
+
+                                patent.setMergeInventor(mergeInventors);
                             }
                         }
+
+                        esService.updateMergePerson(patent, id);
                     }
-                    patent.setMergeApplicant(mergeApplicants);
-                    patent.setMergeRightHolder(mergeApplicants);
-                    esService.updateMergePerson(patent, id);
                 }
             }
         } else {
@@ -287,8 +385,8 @@ public class MergePersonService extends ServiceImpl<MergePersonMapper, MergePers
     public Records getMergePerson(GetAllPersonVO vo) throws Exception {
         Integer projectId = vo.getProjectId();
         Integer taskId = vo.getTaskId();
-        Integer pageNum = vo.getPageNum();
-        Integer pageSize = vo.getPageSize();
+        Long pageNum = vo.getPageNum();
+        Long pageSize = vo.getPageSize();
         Integer type = vo.getType();
         String searchCondition = "";
         if (type == 0 && StringUtils.isNotEmpty(vo.getName())) {
@@ -321,22 +419,16 @@ public class MergePersonService extends ServiceImpl<MergePersonMapper, MergePers
         Query q = formatQueryService.EsQueryToQuery((operateNode) tree, "patent");
         builder.query(q);
         //分页
-        if (pageNum > 0 && pageSize > 0) {
-            builder.from((pageNum - 1) * pageSize).size(pageSize);
-        }
+//        if (pageNum > 0 && pageSize > 0) {
+//            builder.from((pageNum - 1) * pageSize).size(pageSize);
+//        }
         SearchResponse<Patent> response = client.search(builder.build(), Patent.class);
         List<Hit<Patent>> hits = response.hits().hits();
-        long total = response.hits().total().value();
         List<GetEsAllPersonDTO> personDTOS = new ArrayList<>();
         for (Hit<Patent> hit : hits) {
             Patent esMess = hit.source();
             PersonAddress applicantAddr = null;
             GetEsAllPersonDTO personDTO = new GetEsAllPersonDTO();
-            if (ObjectUtil.isNotEmpty(esMess.getApplicantAddr())) {
-                applicantAddr = esMess.getApplicantAddr();
-                personDTO.setAddress(applicantAddr.getAddress());
-                personDTO.setCountry(applicantAddr.getCountry());
-            }
             personDTO.setApplicantAddr(esMess.getApplicantAddr());
             personDTO.setRightHolderAddr(esMess.getRightHolderAddr());
             personDTO.setApplicant(esPatentService.loadName(esMess.getApplicant()));
@@ -345,140 +437,184 @@ public class MergePersonService extends ServiceImpl<MergePersonMapper, MergePers
             personDTOS.add(personDTO);
         }
 
-        //todo 装载地址待定
+        //es申请人/权利人
         List<GetAllPersonDTO> personDTOList = new ArrayList<>();
+        //申请人
         List<GetAllPersonDTO> applicantDTOS = new ArrayList<>();
-        for (GetEsAllPersonDTO personDTO : personDTOS) {
-            PersonAddress applicantAddr = personDTO.getApplicantAddr();
-            if (ObjectUtil.isNotEmpty(applicantAddr)) {
-                List<String> applicant = personDTO.getApplicant();
-                for (String s : applicant) {
-                    GetAllPersonDTO dto = new GetAllPersonDTO();
-                    dto.setName(s);
-                    dto.setType(0);
-                    if (StringUtils.isNotEmpty(applicantAddr.getCountry())) {
-                        dto.setCountry(applicantAddr.getCountry());
+        if (!CollectionUtils.isEmpty(personDTOS)) {
+            for (GetEsAllPersonDTO personDTO : personDTOS) {
+                PersonAddress applicantAddr = personDTO.getApplicantAddr();
+                if (ObjectUtil.isNotEmpty(applicantAddr)) {
+                    List<String> applicant = personDTO.getApplicant();
+                    for (String s : applicant) {
+                        GetAllPersonDTO dto = new GetAllPersonDTO();
+                        dto.setName(s);
+                        dto.setType(0);
+                        if (StringUtils.isNotEmpty(applicantAddr.getCountry())) {
+                            dto.setCountry(applicantAddr.getCountry());
+                        }
+                        if (StringUtils.isNotEmpty(applicantAddr.getAddress())) {
+                            dto.setAddress(applicantAddr.getAddress());
+                        }
+                        applicantDTOS.add(dto);
                     }
-                    if (StringUtils.isNotEmpty(applicantAddr.getAddress())) {
-                        dto.setAddress(applicantAddr.getAddress());
+                } else {
+                    List<String> applicant = personDTO.getApplicant();
+                    for (String s : applicant) {
+                        GetAllPersonDTO dto = new GetAllPersonDTO();
+                        dto.setName(s);
+                        dto.setType(0);
+                        applicantDTOS.add(dto);
                     }
-                    applicantDTOS.add(dto);
-                }
-            } else {
-                List<String> applicant = personDTO.getApplicant();
-                for (String s : applicant) {
-                    GetAllPersonDTO dto = new GetAllPersonDTO();
-                    dto.setName(s);
-                    dto.setType(0);
-                    applicantDTOS.add(dto);
                 }
             }
         }
 
+        //权利人
         List<GetAllPersonDTO> rightDTOS = new ArrayList<>();
-        for (GetEsAllPersonDTO personDTO : personDTOS) {
-            PersonAddress rightHolderAddr = personDTO.getRightHolderAddr();
-            if (ObjectUtil.isNotEmpty(rightHolderAddr)) {
-                List<String> rightHolder = personDTO.getRightHolder();
-                for (String s : rightHolder) {
-                    GetAllPersonDTO dto = new GetAllPersonDTO();
-                    dto.setName(s);
-                    dto.setType(0);
-                    if (StringUtils.isNotEmpty(rightHolderAddr.getCountry())) {
-                        dto.setCountry(rightHolderAddr.getCountry());
+        if (!CollectionUtils.isEmpty(personDTOS)) {
+            for (GetEsAllPersonDTO personDTO : personDTOS) {
+                PersonAddress rightHolderAddr = personDTO.getRightHolderAddr();
+                if (ObjectUtil.isNotEmpty(rightHolderAddr)) {
+                    List<String> rightHolder = personDTO.getRightHolder();
+                    for (String s : rightHolder) {
+                        GetAllPersonDTO dto = new GetAllPersonDTO();
+                        dto.setName(s);
+                        dto.setType(0);
+                        if (StringUtils.isNotEmpty(rightHolderAddr.getCountry())) {
+                            dto.setCountry(rightHolderAddr.getCountry());
+                        }
+                        if (StringUtils.isNotEmpty(rightHolderAddr.getAddress())) {
+                            dto.setAddress(rightHolderAddr.getAddress());
+                        }
+                        rightDTOS.add(dto);
                     }
-                    if (StringUtils.isNotEmpty(rightHolderAddr.getAddress())) {
-                        dto.setAddress(rightHolderAddr.getAddress());
+                } else {
+                    List<String> rightHolder = personDTO.getRightHolder();
+                    for (String s : rightHolder) {
+                        GetAllPersonDTO dto = new GetAllPersonDTO();
+                        dto.setName(s);
+                        dto.setType(0);
+                        rightDTOS.add(dto);
                     }
-                    rightDTOS.add(dto);
-                }
-            } else {
-                List<String> rightHolder = personDTO.getRightHolder();
-                for (String s : rightHolder) {
-                    GetAllPersonDTO dto = new GetAllPersonDTO();
-                    dto.setName(s);
-                    dto.setType(0);
-                    rightDTOS.add(dto);
                 }
             }
         }
 
-        List<GetAllPersonDTO> inventorDTOS = new ArrayList<>();
-        for (GetEsAllPersonDTO personDTO : personDTOS) {
-            List<String> inventor = personDTO.getInventor();
-            for (String s : inventor) {
-                GetAllPersonDTO dto = new GetAllPersonDTO();
-                dto.setName(s);
-                dto.setType(2);
-                inventorDTOS.add(dto);
+        //申请人和权利人相同的去除
+        if (!CollectionUtils.isEmpty(applicantDTOS) && !CollectionUtils.isEmpty(rightDTOS)) {
+            for (GetAllPersonDTO applicantDTO : applicantDTOS) {
+                rightDTOS.removeIf(rightDTO -> applicantDTO.getName().equals(rightDTO.getName()));
             }
         }
+        //装载在同一个集合
+        personDTOList.addAll(applicantDTOS);
+        personDTOList.addAll(rightDTOS);
 
-        List<String> appAndRightList = new ArrayList<>();
-        List<String> inventors = new ArrayList<>();
-        for (GetEsAllPersonDTO personDTO : personDTOS) {
-            appAndRightList.addAll(personDTO.getApplicant());
-            appAndRightList.addAll(personDTO.getRightHolder());
-            inventors.addAll(personDTO.getInventor());
+        //发明人
+        List<GetAllPersonDTO> inventorDTOS = new ArrayList<>();
+        if (!CollectionUtils.isEmpty(personDTOS)) {
+            for (GetEsAllPersonDTO personDTO : personDTOS) {
+                List<String> inventor = personDTO.getInventor();
+                for (String s : inventor) {
+                    GetAllPersonDTO dto = new GetAllPersonDTO();
+                    dto.setName(s);
+                    dto.setType(2);
+                    inventorDTOS.add(dto);
+                }
+            }
         }
 
-        List<String> applicantList = appAndRightList.stream().distinct().collect(Collectors.toList());
-        List<String> inventorList = inventors.stream().distinct().collect(Collectors.toList());
-
-        IPage<MergePerson> page = new Page<>(vo.getPageNum(), vo.getPageSize());
+        //查询合并信息表中数据
+//        IPage<MergePerson> page = new Page<>(vo.getPageNum(), vo.getPageSize());
         LambdaQueryWrapper<MergePerson> wrapper = new LambdaQueryWrapper<MergePerson>()
-                .eq(MergePerson::getProjectId, vo.getProjectId());
-        IPage<MergePerson> record = mergePersonMapper.selectPage(page, wrapper);
-        List<String> applicantMergeList = new ArrayList<>();
-        List<String> inventorMergeList = new ArrayList<>();
-        for (MergePerson person : record.getRecords()) {
-            if (person.getType() == 0) {
-                applicantMergeList = JSONArray.parseArray(person.getMergedName(), String.class);
-            } else if (person.getType() == 2) {
-                inventorMergeList = JSONArray.parseArray(person.getMergedName(), String.class);
+                .eq(MergePerson::getProjectId, vo.getProjectId())
+                .eq(StringUtils.isNotEmpty(vo.getName()), MergePerson::getName, vo.getName())
+                .orderByDesc(MergePerson::getCreateTime);
+//        IPage<MergePerson> record = mergePersonMapper.selectPage(page, wrapper);
+        List<MergePerson> mergePersonList = mergePersonMapper.selectList(wrapper);
+        //合并
+        List<GetAllPersonDTO> mergeList = new ArrayList<>();
+        //申请人/权利人
+        List<GetAllPersonDTO> applicantMergeList = new ArrayList<>();
+        //发明人
+        List<GetAllPersonDTO> inventorMergeList = new ArrayList<>();
+//        List<MergePerson> mergePersonList = record.getRecords();
+        if (!CollectionUtils.isEmpty(mergePersonList)) {
+            for (MergePerson person : mergePersonList) {
+                Integer personType = person.getType();
+                GetAllPersonDTO merge = new GetAllPersonDTO();
+                merge.setName(person.getName());
+                merge.setCountry(person.getCountry());
+                merge.setAddress(person.getAddress());
+                merge.setRemark(person.getRemark());
+                merge.setType(personType);
+                merge.setMergeId(person.getId());
+                mergeList.add(merge);
+
+                if (personType == 0) {
+                    List<String> applicantMerges = JSONArray.parseArray(person.getMergedName(), String.class);
+                    if (!CollectionUtils.isEmpty(applicantMerges)) {
+                        for (String applicantMerge : applicantMerges) {
+                            GetAllPersonDTO applicant = new GetAllPersonDTO();
+                            applicant.setName(applicantMerge);
+                            applicant.setCountry(person.getCountry());
+                            applicant.setAddress(person.getAddress());
+                            applicant.setRemark(person.getRemark());
+                            applicant.setType(personType);
+                            applicantMergeList.add(applicant);
+                        }
+                    }
+                } else if (person.getType() == 2) {
+                    List<String> inventorMerges = JSONArray.parseArray(person.getMergedName(), String.class);
+                    if (!CollectionUtils.isEmpty(inventorMerges)) {
+                        for (String inventorMerge : inventorMerges) {
+                            GetAllPersonDTO inventor = new GetAllPersonDTO();
+                            inventor.setName(inventorMerge);
+                            inventor.setCountry(person.getCountry());
+                            inventor.setAddress(person.getAddress());
+                            inventor.setRemark(person.getRemark());
+                            inventor.setType(personType);
+                            inventorMergeList.add(inventor);
+                        }
+                    }
+                }
             }
         }
-        applicantList.removeAll(applicantMergeList);
-        inventorList.removeAll(inventorMergeList);
-//        List<GetAllPersonDTO> applicantDTOS = new ArrayList<>();
-//        List<GetAllPersonDTO> inventorDTOS = new ArrayList<>();
-        for (String applicant : applicantList) {
-            GetAllPersonDTO dto = new GetAllPersonDTO();
-            dto.setName(applicant);
-            dto.setType(0);
-            applicantDTOS.add(dto);
+        //申请人/权利人
+        if (!CollectionUtils.isEmpty(personDTOList) && !CollectionUtils.isEmpty(applicantMergeList)) {
+            for (GetAllPersonDTO applicantMerge : applicantMergeList) {
+                personDTOList.removeIf(personDTO -> personDTO.getName().equals(applicantMerge.getName()));
+            }
         }
-        for (String inventor : inventorList) {
-            GetAllPersonDTO dto = new GetAllPersonDTO();
-            dto.setName(inventor);
-            dto.setType(2);
-            inventorDTOS.add(dto);
+        //发明人
+        if (!CollectionUtils.isEmpty(inventorDTOS) && !CollectionUtils.isEmpty(inventorMergeList)) {
+            for (GetAllPersonDTO inventorMerge : inventorMergeList) {
+                inventorDTOS.removeIf(inventor -> inventor.getName().equals(inventorMerge.getName()));
+            }
         }
 
-        Records records = new Records();
-        records.setCurrent(vo.getPageNum().longValue());
-        records.setSize(vo.getPageSize().longValue());
-        if (vo.getType() == 0) {
-            int size = applicantDTOS.size();
-            records.setData(applicantDTOS.stream().limit(vo.getPageSize()).collect(Collectors.toList()));
-            if (total >= size) {
-                records.setTotal((long) size);
-            } else {
-                records.setTotal(total);
-            }
-        } else if (vo.getType() == 2) {
-            int size = inventorDTOS.size();
-            records.setData(inventorDTOS.stream().limit(vo.getPageSize()).collect(Collectors.toList()));
-            if (total >= size) {
-                records.setTotal((long) size);
-            } else {
-                records.setTotal(total);
-            }
+        //申请人/权利人、发明人返回数据
+        List<GetAllPersonDTO> list = new ArrayList<>();
+        if (type == 0) {
+            list.addAll(mergeList);
+            list.addAll(personDTOList);
+        } else {
+            list.addAll(mergeList);
+            list.addAll(inventorDTOS);
         }
+
+        List<GetAllPersonDTO> collect = list.stream().skip((pageNum - 1) * pageSize).limit(pageSize).collect(Collectors.toList());
+
+        Records records = new Records();
+        records.setCurrent(pageNum);
+        records.setSize(pageSize);
+        records.setData(collect);
+        records.setTotal((long) list.size());
         return records;
     }
 
-
+    @Transactional(propagation = Propagation.REQUIRED, rollbackFor = Throwable.class)
     public Integer delMergedName(MergedNameVO vo) throws IOException {
         Integer type = vo.getType();
         String delName = vo.getDelName();
@@ -542,6 +678,7 @@ public class MergePersonService extends ServiceImpl<MergePersonMapper, MergePers
         return mergePerson.getId();
     }
 
+    @Transactional(propagation = Propagation.REQUIRED, rollbackFor = Throwable.class)
     public Integer delMergePerson(MergePersonIdVO vo) throws IOException {
         Integer type = vo.getType();
         MergePerson mergePerson = mergePersonMapper.selectById(vo.getId());
@@ -586,4 +723,24 @@ public class MergePersonService extends ServiceImpl<MergePersonMapper, MergePers
         }
         return vo.getId();
     }
+
+    /**
+     * 获取所有国家列表查询
+     * @return
+     */
+    public List<GetAllCountryDTO> getAllCountry() {
+        List<GetAllCountryDTO> list = new ArrayList<>();
+        List<SystemDict> countries = systemDictMapper.selectList(new LambdaQueryWrapper<SystemDict>()
+                .eq(SystemDict::getType, "COUNTRIES"));
+        if (!CollectionUtils.isEmpty(countries)) {
+            countries.forEach(county -> {
+                GetAllCountryDTO dto = new GetAllCountryDTO();
+                dto.setLabel(county.getLabel());
+                dto.setValue(county.getValue());
+                dto.setType(county.getType());
+                list.add(dto);
+            });
+        }
+        return list;
+    }
 }

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

@@ -1,9 +1,6 @@
 package cn.cslg.pas.service;
 
-import cn.cslg.pas.common.dto.PatentColumnDTO;
-import cn.cslg.pas.common.dto.PatentDTO;
-import cn.cslg.pas.common.dto.PatentDetailDTO;
-import cn.cslg.pas.common.dto.PatentKinDTO;
+import cn.cslg.pas.common.dto.*;
 import cn.cslg.pas.common.dto.business.EsCountDTO;
 import cn.cslg.pas.common.dto.business.EsPatentFamilyDTO;
 import cn.cslg.pas.common.dto.business.ReportTempleDTO;
@@ -36,6 +33,7 @@ import org.junit.jupiter.api.Test;
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.boot.test.context.SpringBootTest;
 import org.springframework.mock.web.MockMultipartFile;
+import org.springframework.transaction.annotation.Transactional;
 import org.springframework.web.multipart.MultipartFile;
 
 import java.io.File;
@@ -412,4 +410,74 @@ public class EventServiceTests {
         Integer type = 0;
         esService.delMergePerson(patent, id, type, name);
     }
+
+    @Test
+    public void test100() {
+        List<GetAllPersonDTO> DTOS = new ArrayList<>();
+        List<GetAllPersonDTO> applicantDTOS = new ArrayList<>();
+        GetAllPersonDTO dto = new GetAllPersonDTO();
+        dto.setName("A");
+        dto.setType(0);
+        dto.setCountry("CN");
+        dto.setAddress("efe");
+        applicantDTOS.add(dto);
+        GetAllPersonDTO dto1 = new GetAllPersonDTO();
+        dto1.setName("B");
+        dto1.setType(0);
+        dto1.setCountry("CN");
+        dto1.setAddress("weew");
+        applicantDTOS.add(dto1);
+        GetAllPersonDTO dto2 = new GetAllPersonDTO();
+        dto2.setName("C");
+        dto2.setType(0);
+        dto2.setCountry("CN");
+        dto2.setAddress("fdsyt");
+        applicantDTOS.add(dto2);
+        List<GetAllPersonDTO> rightDTOS = new ArrayList<>();
+        GetAllPersonDTO dto4 = new GetAllPersonDTO();
+        dto4.setName("A");
+        dto4.setType(0);
+        dto4.setCountry("CN");
+        dto4.setAddress("efed");
+        rightDTOS.add(dto4);
+        GetAllPersonDTO dto5 = new GetAllPersonDTO();
+        dto5.setName("D");
+        dto5.setType(0);
+        dto5.setCountry("CN");
+        dto5.setAddress("ete");
+        rightDTOS.add(dto5);
+        GetAllPersonDTO dto6 = new GetAllPersonDTO();
+        dto6.setName("E");
+        dto6.setType(0);
+        rightDTOS.add(dto6);
+
+        applicantDTOS.removeAll(rightDTOS);
+        System.out.println(applicantDTOS + "-----------------");
+
+        for (GetAllPersonDTO applicantDTO : applicantDTOS) {
+            rightDTOS.removeIf(rightDTO -> applicantDTO.getName().equals(rightDTO.getName()));
+        }
+
+        System.out.println(applicantDTOS);
+        System.out.println(rightDTOS);
+
+        DTOS.addAll(applicantDTOS);
+        DTOS.addAll(rightDTOS);
+        System.out.println("DTOS:" + DTOS);
+    }
+
+    @Test
+    public void test101() {
+
+    }
+
+    @Transactional
+    public void tran() {
+
+    }
+
+    @Transactional
+    public void tran1() {
+
+    }
 }