fixed:合并

src/main/java/cn/cslg/pas/common/dto/es/EsMergePersonDTO.java

@@ -0,0 +1,19 @@
+package cn.cslg.pas.common.dto.es;
+
+import lombok.Data;
+
+@Data
+public class EsMergePersonDTO {
+
+    private String id;
+
+    private String routing;
+
+    private String name;
+
+    private Integer order;
+
+    private String type;
+
+    private String projectId;
+}

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

@@ -8,13 +8,9 @@ import java.util.List;
 @Data
 public class GetEsAllPersonDTO {
 
-    private List<String> applicant;
+    private List<String> mergeApplicant;
 
-    private List<String> rightHolder;
+    private List<String> mergeRightHolder;
 
-    private List<String> inventor;
-
-    private PersonAddress applicantAddr;
-
-    private PersonAddress rightHolderAddr;
+    private List<String> mergeInventor;
 }

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

@@ -6,9 +6,9 @@ import java.util.List;
 
 @Data
 public class MergePersonAgainVO {
-
+    //已存在的合并后名称
     private List<String> needMergedName;
-
+    //存在再次要合并的名称
     private List<String> mergedName;
 
     private Integer projectId;

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

@@ -4,6 +4,7 @@ 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;
+import cn.cslg.pas.common.dto.es.EsMergePersonDTO;
 import cn.cslg.pas.common.dto.patentCount.GetEsAllPersonDTO;
 import cn.cslg.pas.common.model.cronModel.PersonnelVO;
 import cn.cslg.pas.common.model.cronModel.Records;
@@ -17,10 +18,7 @@ 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.domain.es.*;
 import cn.cslg.pas.exception.UnLoginException;
 import cn.cslg.pas.exception.XiaoShiException;
 import cn.cslg.pas.mapper.MergePersonMapper;
@@ -31,15 +29,18 @@ import cn.cslg.pas.service.query.FormatQueryService;
 import cn.hutool.core.util.ObjectUtil;
 import cn.hutool.core.util.PageUtil;
 import co.elastic.clients.elasticsearch.ElasticsearchClient;
+import co.elastic.clients.elasticsearch._types.InlineScript;
+import co.elastic.clients.elasticsearch._types.Script;
 import co.elastic.clients.elasticsearch._types.aggregations.Aggregation;
 import co.elastic.clients.elasticsearch._types.aggregations.AggregationBuilders;
 import co.elastic.clients.elasticsearch._types.aggregations.NestedAggregation;
 import co.elastic.clients.elasticsearch._types.aggregations.TermsAggregation;
+import co.elastic.clients.elasticsearch._types.query_dsl.IdsQuery;
 import co.elastic.clients.elasticsearch._types.query_dsl.Query;
 import co.elastic.clients.elasticsearch._types.query_dsl.QueryBuilders;
-import co.elastic.clients.elasticsearch.core.SearchRequest;
-import co.elastic.clients.elasticsearch.core.SearchResponse;
+import co.elastic.clients.elasticsearch.core.*;
 import co.elastic.clients.elasticsearch.core.search.Hit;
+import co.elastic.clients.json.JsonData;
 import com.alibaba.fastjson.JSONArray;
 import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
 import com.baomidou.mybatisplus.core.metadata.IPage;
@@ -48,6 +49,7 @@ import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
 import com.github.pagehelper.PageHelper;
 import com.google.gson.JsonArray;
 import lombok.extern.slf4j.Slf4j;
+import org.apache.commons.lang3.ObjectUtils;
 import org.apache.commons.lang3.StringUtils;
 import org.springframework.beans.BeanUtils;
 import org.springframework.beans.factory.annotation.Autowired;
@@ -88,6 +90,7 @@ public class MergePersonService extends ServiceImpl<MergePersonMapper, MergePers
     public Integer mergePerson(MergePersonVO vo) throws Exception {
         Integer type = vo.getType();
         List<String> mergedNames = vo.getMergedName();
+        Integer projectId = vo.getProjectId();
         //获取登陆人信息 用于设置创建人
         PersonnelVO personnelVO = new PersonnelVO();
         try {
@@ -118,18 +121,29 @@ public class MergePersonService extends ServiceImpl<MergePersonMapper, MergePers
         List<Query> queries = new ArrayList<>();
         if (type == 0) {
             for (String mergedName : mergedNames) {
-                Query q1 = QueryBuilders.term(i -> i.field("applicant.name.key").value(mergedName));
-                Query query1 = QueryBuilders.nested(i -> i.path("applicant").query(q1));
-                Query q2 = QueryBuilders.term(i -> i.field("right_holder.name.key").value(mergedName));
-                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(mergedName));
+                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(mergedName));
+                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 {
             for (String mergedName : mergedNames) {
-                Query q = QueryBuilders.term(i -> i.field("inventor.name.key").value(mergedName));
-                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(mergedName));
+                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));
@@ -156,32 +170,110 @@ public class MergePersonService extends ServiceImpl<MergePersonMapper, MergePers
                 if (type == 0) {
                     //申请人
                     List<PatentMergePerson> mergeApplicants = new ArrayList<>();
-                    if (!CollectionUtils.isEmpty(patent.getMergeApplicant())) {
-                        mergeApplicants = patent.getMergeApplicant();
+                    List<PatentMergePerson> mergeApplicant = this.getChildMergePerson(id, projectId, "merge_applicant");
+                    if (!CollectionUtils.isEmpty(mergeApplicant)) {
+                        for (String mergedName : mergedNames) {
+                            mergeApplicant.removeIf(app -> app.getName().equals(mergedName));
+                        }
                     }
                     mergeApplicants.addAll(mergePersonList);
+                    patent.setMergeApplicant(mergeApplicants);
+                    PatentJoin patentJoin = new PatentJoin();
+                    patentJoin.setParent(id);
+                    patentJoin.setName("merge_applicat");
+                    patent.setPatentJoin(patentJoin);
+                    try {
+                        esService.addChildPatent(patent, id);
+                    } catch (Exception e) {
+                    }
                     //权利人
-                    List<PatentMergePerson> mergeRightHolder = new ArrayList<>();
+                    List<PatentMergePerson> mergeRightHolders = new ArrayList<>();
+                    List<PatentMergePerson> mergeRightHolder = this.getChildMergePerson(id, projectId, "merge_right_holder");
                     if (!CollectionUtils.isEmpty(patent.getMergeRightHolder())) {
-                        mergeRightHolder = patent.getMergeRightHolder();
+                        for (String mergedName : mergedNames) {
+                            mergeRightHolder.removeIf(right -> right.getName().equals(mergedName));
+                        }
+                    }
+                    mergeRightHolders.addAll(mergePersonList);
+                    patent.setMergeRightHolder(mergeRightHolders);
+                    PatentJoin join = new PatentJoin();
+                    join.setParent(id);
+                    join.setName("merge_right_holder");
+                    patent.setPatentJoin(join);
+                    try {
+                        esService.addChildPatent(patent, id);
+                    } catch (Exception e) {
                     }
-                    mergeRightHolder.addAll(mergePersonList);
-                    patent.setMergeApplicant(mergeApplicants);
-                    patent.setMergeRightHolder(mergeRightHolder);
                 } else if (type == 2) {
-                    List<PatentMergePerson> mergeInventor = new ArrayList<>();
+                    List<PatentMergePerson> mergeInventors = new ArrayList<>();
+                    List<PatentMergePerson> mergeInventor = this.getChildMergePerson(id, projectId, "merge_inventor");
                     if (!CollectionUtils.isEmpty(patent.getMergeInventor())) {
-                        mergeInventor = patent.getMergeInventor();
+                        for (String mergedName : mergedNames) {
+                            mergeInventor.removeIf(inventor -> inventor.getName().equals(mergedName));
+                        }
+                    }
+                    mergeInventors.addAll(mergePersonList);
+                    patent.setMergeInventor(mergeInventors);
+                    PatentJoin join = new PatentJoin();
+                    join.setParent(id);
+                    join.setName("merge_inventor");
+                    patent.setPatentJoin(join);
+                    try {
+                        esService.addChildPatent(patent, id);
+                    } catch (Exception e) {
                     }
-                    mergeInventor.addAll(mergePersonList);
-                    patent.setMergeInventor(mergeInventor);
                 }
-                esService.updateMergePerson(patent, id);
             }
         }
         return person.getId();
     }
 
+    public List<PatentMergePerson> getChildMergePerson(String id, Integer projectId, String mergeType) throws IOException {
+        List<PatentMergePerson> list = new ArrayList<>();
+        String path = mergeType + "." + "project_id";
+        SearchRequest.Builder builder = new SearchRequest.Builder();
+        //设置查询索引
+        builder.index("patent");
+        Query idQ = QueryBuilders.term(i -> i.field(path).value(projectId));
+        Query query = QueryBuilders.nested(i -> i.path(mergeType).query(idQ));
+        IdsQuery idsQuery = IdsQuery.of(n -> n.values(Arrays.asList(id)));
+        Query q = QueryBuilders.hasParent(i -> i.parentType("patent").query(j -> j.ids(idsQuery)));
+        Query bool = QueryBuilders.bool(i -> i.must(q, query));
+        builder.query(bool);
+        SearchResponse<PatentMergePerson> response = client.search(builder.build(), PatentMergePerson.class);
+        List<Hit<PatentMergePerson>> hits = response.hits().hits();
+        for (Hit<PatentMergePerson> hit : hits) {
+            PatentMergePerson person = hit.source();
+            list.add(person);
+        }
+        return list;
+    }
+
+    public List<EsMergePersonDTO> getChildMergePersonDTO(String id, Integer projectId, String mergeType) throws IOException {
+        List<EsMergePersonDTO> list = new ArrayList<>();
+        String path = mergeType + "." + "project_id";
+        SearchRequest.Builder builder = new SearchRequest.Builder();
+        //设置查询索引
+        builder.index("patent");
+        Query idQ = QueryBuilders.term(i -> i.field(path).value(projectId));
+        Query query = QueryBuilders.nested(i -> i.path(mergeType).query(idQ));
+        IdsQuery idsQuery = IdsQuery.of(n -> n.values(Arrays.asList(id)));
+        Query q = QueryBuilders.hasParent(i -> i.parentType("patent").query(j -> j.ids(idsQuery)));
+        Query bool = QueryBuilders.bool(i -> i.must(q, query));
+        builder.query(bool);
+        SearchResponse<PatentMergePerson> response = client.search(builder.build(), PatentMergePerson.class);
+        List<Hit<PatentMergePerson>> hits = response.hits().hits();
+        for (Hit<PatentMergePerson> hit : hits) {
+            PatentMergePerson person = hit.source();
+            EsMergePersonDTO dto = new EsMergePersonDTO();
+            dto.setId(hit.id());
+            dto.setRouting(hit.routing());
+            BeanUtils.copyProperties(person, dto);
+            list.add(dto);
+        }
+        return list;
+    }
+
     @Transactional(propagation = Propagation.REQUIRED, rollbackFor = Throwable.class)
     public Integer mergePersonAgain(MergePersonAgainVO vo) throws Exception {
         List<String> mergedNames = vo.getNeedMergedName();
@@ -240,38 +332,43 @@ public class MergePersonService extends ServiceImpl<MergePersonMapper, MergePers
         }
         //获取老专利
         MergePerson person = this.getById(vo.getId());
-        String mergedName = person.getMergedName();
         String name = person.getName();
+        Integer projectId = person.getProjectId();
 
         if (ObjectUtil.isNotEmpty(person)) {
             BeanUtils.copyProperties(vo, person);
-//            person.setMergedName(JSONArray.toJSONString(vo.getMergedName()));
             person.setCreateId(personnelVO.getId());
             person.setCreateTime(new Date());
             person.updateById();
 
             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);
-                    }
+                    //合并申请人
+                    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 {
-                    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 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);
@@ -289,16 +386,29 @@ public class MergePersonService extends ServiceImpl<MergePersonMapper, MergePers
                         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());
+                            List<EsMergePersonDTO> mergeApplicant = this.getChildMergePersonDTO(id, projectId, "merge_applicant");
+                            if (!CollectionUtils.isEmpty(mergeApplicant)) {
+                                for (EsMergePersonDTO mergePerson : mergeApplicant) {
+                                    if (mergePerson.getName().equals(name)) {
+                                        mergePerson.setName(vo.getName());
                                     }
                                 }
-
-                                patent.setMergeApplicant(mergeApplicants);
+                            }
+                            for (EsMergePersonDTO dto : mergeApplicant) {
+                                PatentMergePerson per = new PatentMergePerson();
+                                BeanUtils.copyProperties(dto, per);
+                                mergeApplicants.add(per);
+                            }
+                            patent.setMergeApplicant(mergeApplicants);
+                            PatentJoin patentJoin = new PatentJoin();
+                            patentJoin.setParent(id);
+                            patentJoin.setName("merge_applicat");
+                            patent.setPatentJoin(patentJoin);
+                            try {
+                                for (EsMergePersonDTO dto : mergeApplicant) {
+                                    this.edit(patent, dto.getId(), dto.getRouting());
+                                }
+                            } catch (Exception e) {
                             }
 
                             //权利人
@@ -328,8 +438,7 @@ public class MergePersonService extends ServiceImpl<MergePersonMapper, MergePers
                                 patent.setMergeInventor(mergeInventors);
                             }
                         }
-
-                        esService.updateMergePerson(patent, id);
+                        this.editMergePerson(patent, id);
                     }
                 }
             }
@@ -385,241 +494,132 @@ public class MergePersonService extends ServiceImpl<MergePersonMapper, MergePers
 
     public Records getMergePerson(GetAllPersonVO vo) throws Exception {
         Integer projectId = vo.getProjectId();
-        Integer taskId = vo.getTaskId();
         Long pageNum = vo.getPageNum();
         Long pageSize = vo.getPageSize();
         Integer type = vo.getType();
-        String searchCondition = "";
-        if (type == 0 && StringUtils.isNotEmpty(vo.getName())) {
-            searchCondition = searchCondition + "PA = " + vo.getName() + " " + "OR" + " " + "PE =" + vo.getName();
-        } else if (type == 2 && StringUtils.isNotEmpty(vo.getName())) {
-            searchCondition = searchCondition + "IN = " + vo.getName();
-        }
-        if (taskId != null) {
-            if (searchCondition != null && !"".equals(searchCondition.trim())) {
-                searchCondition = "taskId = " + taskId + " AND " + searchCondition;
+        String condition = vo.getSearchQuery();
+        String name = vo.getName();
+
+        SearchRequest.Builder builder = new SearchRequest.Builder();
+        //设置查询索引
+        builder.index("patent");
+        List<Query> queries = new ArrayList<>();
+        if (type == 0) {
+            Query q1 = QueryBuilders.term(i -> i.field("merge_applicant.project_id").value(projectId));
+            Query query1 = QueryBuilders.nested(i -> i.path("merge_applicant").query(q1));
+            if (StringUtils.isNotEmpty(name)) {
+                Query q3 = QueryBuilders.match(i -> i.field("merge_applicant.name").query(name));
+                Query query3 = QueryBuilders.nested(i -> i.path("merge_applicant").query(q3));
+                Query bool = QueryBuilders.bool(i -> i.must(query1).should(query3));
+                queries.add(bool);
+            } else {
+                queries.add(query1);
+            }
+
+            Query q2 = QueryBuilders.term(i -> i.field("merge_right_holder.project_id").value(projectId));
+            Query query2 = QueryBuilders.nested(i -> i.path("merge_right_holder").query(q2));
+            if (StringUtils.isNotEmpty(name)) {
+                Query q4 = QueryBuilders.match(i -> i.field("merge_right_holder.name").query(name));
+                Query query4 = QueryBuilders.nested(i -> i.path("merge_applicant").query(q4));
+                Query bool1 = QueryBuilders.bool(i -> i.must(query2).should(query4));
+                queries.add(bool1);
             } else {
-                searchCondition = "taskId = " + taskId;
+                queries.add(query2);
             }
         } else {
-            if (projectId != null) {
-                if (searchCondition != null && !"".equals(searchCondition.trim())) {
-                    searchCondition = "projectId = " + projectId + " AND " + searchCondition;
-                } else {
-                    searchCondition = "projectId = " + projectId;
-                }
+            Query q = QueryBuilders.term(i -> i.field("merge_inventor.project_id").value(projectId));
+            Query query = QueryBuilders.nested(i -> i.path("merge_inventor").query(q));
+            if (StringUtils.isNotEmpty(name)) {
+                Query q5 = QueryBuilders.match(i -> i.field("merge_inventor.name").query(name));
+                Query query5 = QueryBuilders.nested(i -> i.path("merge_inventor").query(q5));
+                Query bool1 = QueryBuilders.bool(i -> i.must(query).should(query5));
+                queries.add(bool1);
+            } else {
+                queries.add(query);
             }
         }
-        SearchRequest.Builder builder = new SearchRequest.Builder();
-        //设置查询索引
-        builder.index("patent");
-        //1. 解析检索条件
-        treeNode tree = expressManager.getInstance().Parse(searchCondition, false);
-        //格式化检索式
-        //3. 从es中检索数据
-        Query q = formatQueryService.EsQueryToQuery((operateNode) tree, "patent");
-        builder.query(q);
+        Query bool = QueryBuilders.bool(i -> i.should(queries));
+        builder.query(bool);
         //分页
 //        if (pageNum > 0 && pageSize > 0) {
-//            builder.from((pageNum - 1) * pageSize).size(pageSize);
+//            builder.from((pageNum.intValue() - 1) * pageSize.intValue()).size(pageSize.intValue());
 //        }
+
         SearchResponse<Patent> response = client.search(builder.build(), Patent.class);
         List<Hit<Patent>> hits = response.hits().hits();
         List<GetEsAllPersonDTO> personDTOS = new ArrayList<>();
         for (Hit<Patent> hit : hits) {
             Patent esMess = hit.source();
             GetEsAllPersonDTO personDTO = new GetEsAllPersonDTO();
-            personDTO.setApplicantAddr(esMess.getApplicantAddr());
-            personDTO.setRightHolderAddr(esMess.getRightHolderAddr());
-            personDTO.setApplicant(esPatentService.loadName(esMess.getApplicant()));
-            personDTO.setRightHolder(esPatentService.loadName(esMess.getRightHolder()));
-            personDTO.setInventor(esPatentService.loadName(esMess.getInventor()));
+            if (!CollectionUtils.isEmpty(esMess.getMergeInventor())) {
+                personDTO.setMergeApplicant(esPatentService.loadMergeName(esMess.getMergeApplicant()));
+            }
+            if (!CollectionUtils.isEmpty(esMess.getMergeRightHolder())) {
+                personDTO.setMergeRightHolder(esPatentService.loadMergeName(esMess.getMergeRightHolder()));
+            }
+            if (!CollectionUtils.isEmpty(esMess.getMergeInventor())) {
+                personDTO.setMergeInventor(esPatentService.loadMergeName(esMess.getMergeInventor()));
+            }
             personDTOS.add(personDTO);
         }
 
         //es申请人/权利人
         List<GetAllPersonDTO> personDTOList = new ArrayList<>();
-        //申请人
-        List<GetAllPersonDTO> applicantDTOS = new ArrayList<>();
-        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);
-                    }
-                } 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<>();
+        List<String> mergeList = new ArrayList<>();
         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(1);
-                        if (StringUtils.isNotEmpty(rightHolderAddr.getCountry())) {
-                            dto.setCountry(rightHolderAddr.getCountry());
-                        }
-                        if (StringUtils.isNotEmpty(rightHolderAddr.getAddress())) {
-                            dto.setAddress(rightHolderAddr.getAddress());
-                        }
-                        rightDTOS.add(dto);
+            if (type == 0) {
+                for (GetEsAllPersonDTO personDTO : personDTOS) {
+                    List<String> appList = new ArrayList<>();
+                    if (!CollectionUtils.isEmpty(personDTO.getMergeApplicant())) {
+                        appList = personDTO.getMergeApplicant();
+                        mergeList.addAll(appList);
                     }
-                } else {
-                    List<String> rightHolder = personDTO.getRightHolder();
-                    for (String s : rightHolder) {
-                        GetAllPersonDTO dto = new GetAllPersonDTO();
-                        dto.setName(s);
-                        dto.setType(1);
-                        rightDTOS.add(dto);
+                    List<String> rightList = new ArrayList<>();
+                    if (!CollectionUtils.isEmpty(personDTO.getMergeRightHolder())) {
+                        rightList = personDTO.getMergeRightHolder();
+                        mergeList.addAll(rightList);
                     }
-                }
-            }
-        }
 
-        //申请人和权利人相同的去除
-        if (!CollectionUtils.isEmpty(applicantDTOS) && !CollectionUtils.isEmpty(rightDTOS)) {
-            for (GetAllPersonDTO applicantDTO : applicantDTOS) {
-                rightDTOS.removeIf(rightDTO -> rightDTO.getName().equals(applicantDTO.getName()));
-            }
-        }
-        //装载在同一个集合
-        personDTOList.addAll(applicantDTOS);
-        personDTOList.addAll(rightDTOS);
-
-        if (!CollectionUtils.isEmpty(personDTOList)) {
-            Set<GetAllPersonDTO> set = new TreeSet<>(Comparator.comparing(GetAllPersonDTO::getName));
-            set.addAll(personDTOList);
-            personDTOList = new ArrayList<>(set);
-        }
 
-        //发明人
-        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);
                 }
-            }
-        }
-
-        //查询合并信息表中数据
-//        IPage<MergePerson> page = new Page<>(vo.getPageNum(), vo.getPageSize());
-        LambdaQueryWrapper<MergePerson> wrapper = new LambdaQueryWrapper<MergePerson>()
-                .eq(MergePerson::getProjectId, vo.getProjectId())
-                .eq(MergePerson::getType, type)
-                .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());
-                merge.setAbbreviation(person.getAbbreviation());
-                merge.setProvince(person.getProvince());
-                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);
-                        }
+            } else {
+                for (GetEsAllPersonDTO personDTO : personDTOS) {
+                    List<String> inventorList = new ArrayList<>();
+                    if (!CollectionUtils.isEmpty(personDTO.getMergeInventor())) {
+                        inventorList = personDTO.getMergeInventor();
+                        mergeList.addAll(inventorList);
                     }
+
                 }
             }
         }
-        //申请人/权利人
-        if (!CollectionUtils.isEmpty(personDTOList) && !CollectionUtils.isEmpty(applicantMergeList)) {
-            for (GetAllPersonDTO applicantMerge : applicantMergeList) {
-                personDTOList.removeIf(personDTO -> personDTO.getName().equals(applicantMerge.getName()));
-            }
-        }
-        //发明人
-        if (!CollectionUtils.isEmpty(inventorDTOS) && !CollectionUtils.isEmpty(inventorMergeList)) {
-            for (GetAllPersonDTO inventorMerge : inventorMergeList) {
-                inventorDTOS.removeIf(inventor -> inventor.getName().equals(inventorMerge.getName()));
+
+        List<String> nameList = mergeList.stream().distinct().collect(Collectors.toList());
+        for (String key : nameList) {
+            MergePerson person = mergePersonMapper.selectOne(new LambdaQueryWrapper<MergePerson>()
+                    .eq(MergePerson::getName, key));
+            GetAllPersonDTO dto = new GetAllPersonDTO();
+            dto.setName(key);
+            if (ObjectUtils.isNotEmpty(person)) {
+                dto.setMergeId(person.getId());
+                dto.setType(person.getType());
+                dto.setRemark(person.getRemark());
+                dto.setAbbreviation(person.getAbbreviation());
+                dto.setCountry(person.getCountry());
+                dto.setProvince(person.getProvince());
             }
+            personDTOList.add(dto);
         }
 
-        //申请人/权利人、发明人返回数据
-        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());
+        List<GetAllPersonDTO> collect = personDTOList.stream().skip((pageNum - 1) * pageSize).limit(pageSize)
+                .sorted(Comparator.comparing(GetAllPersonDTO::getName).reversed()).collect(Collectors.toList());
 
         Records records = new Records();
         records.setCurrent(pageNum);
         records.setSize(pageSize);
         records.setData(collect);
-        records.setTotal((long) list.size());
+        records.setTotal((long) personDTOList.size());
         return records;
     }
 
@@ -648,13 +648,13 @@ public class MergePersonService extends ServiceImpl<MergePersonMapper, MergePers
             List<Query> mustQueries = new ArrayList<>();
             if (type == 0) {
                 Query q1 = QueryBuilders.term(i -> i.field("applicant.name.key").value(delName));
-                Query query1 = QueryBuilders.nested(i -> i.path("applicant").query(q1));
+                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 q3 = QueryBuilders.term(i -> i.field("merge_applicant.name.raw").value(name));
-                Query query3 = QueryBuilders.nested(i -> i.path("merge_applicant").query(q3));
+                Query query3 = QueryBuilders.nested(i -> i.path("merge_applicat").query(q3));
                 Query q4 = QueryBuilders.term(i -> i.field("merge_right_holder.name.raw").value(name));
                 Query query4 = QueryBuilders.nested(i -> i.path("merge_right_holder").query(q4));
                 mustQueries.add(query3);
@@ -680,7 +680,7 @@ public class MergePersonService extends ServiceImpl<MergePersonMapper, MergePers
             if (!CollectionUtils.isEmpty(map)) {
                 for (String id : map.keySet()) {
                     Patent patent = map.get(id);
-                    esService.delMergePerson(patent, id, type, mergePerson.getName());
+                    this.delSingleMerge(patent, id, type, mergePerson.getName());
                 }
             }
         }
@@ -691,13 +691,14 @@ public class MergePersonService extends ServiceImpl<MergePersonMapper, MergePers
     public Integer delMergePerson(MergePersonIdVO vo) throws IOException {
         Integer type = vo.getType();
         MergePerson mergePerson = mergePersonMapper.selectById(vo.getId());
+        String name = mergePerson.getName();
+        Integer projectId = mergePerson.getProjectId();
+        String mergedName = mergePerson.getMergedName();
         if (ObjectUtil.isNotEmpty(mergePerson)) {
             LambdaQueryWrapper<MergePerson> wrapper = new LambdaQueryWrapper<MergePerson>()
                     .eq(BaseEntity::getId, vo.getId());
             this.remove(wrapper);
 
-            String name = mergePerson.getName();
-            String mergedName = mergePerson.getMergedName();
             List<String> list = JSONArray.parseArray(mergedName, String.class);
             if (!CollectionUtils.isEmpty(list)) {
                 SearchRequest.Builder builder = new SearchRequest.Builder();
@@ -705,32 +706,40 @@ public class MergePersonService extends ServiceImpl<MergePersonMapper, MergePers
                 builder.index("patent");
                 List<Query> queries = new ArrayList<>();
                 if (type == 0) {
+                    //合并申请人
+                    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 query1 = QueryBuilders.nested(i -> i.path("merge_applicant").query(q1));
+                    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 query2 = QueryBuilders.nested(i -> i.path("merge_right_holder").query(q2));
-                    queries.add(query1);
-                    queries.add(query2);
+                    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 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 query3 = QueryBuilders.nested(i -> i.path("merge_inventor").query(q));
-                    queries.add(query3);
+                    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.must(queries));
+                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<>();
+                List<String> ids = new ArrayList<>();
                 for (Hit<Patent> hit : hits) {
                     String id = hit.id();
-                    map.put(id, hit.source());
+                    ids.add(id);
                 }
 
-                if (!CollectionUtils.isEmpty(map)) {
-                    for (String id : map.keySet()) {
-                        Patent patent = map.get(id);
-                        esService.delMergePerson(patent, id, type, mergePerson.getName());
-                    }
+                if (!CollectionUtils.isEmpty(ids)) {
+                    this.delete(ids);
                 }
             }
         }
@@ -776,4 +785,78 @@ public class MergePersonService extends ServiceImpl<MergePersonMapper, MergePers
         }
         return list;
     }
+
+    public Integer delete(List<String> ids) {
+        Query query = QueryBuilders.ids(n -> n.values(ids));
+        DeleteByQueryRequest request = DeleteByQueryRequest.of(i -> i.index("patent").query(query));
+        try {
+            client.deleteByQuery(request);
+            return 1;
+        } catch (IOException e) {
+            throw new XiaoShiException("删除失败");
+        }
+    }
+
+    /**
+     * 更新合并申请人/权利人/发明人
+     * @param patent
+     * @param id
+     * @return
+     */
+    public Integer editMergePerson(Patent patent, String id) {
+        List<PatentMergePerson> mergeApplicant = patent.getMergeApplicant();
+        String source = "";
+        InlineScript inlineScript = InlineScript.of(i -> i.lang("painless").source(source));
+        Script script = Script.of(i -> i.inline(inlineScript));
+        Query query = QueryBuilders.term(i -> i.field("_id").value(id));
+        UpdateByQueryRequest request = UpdateByQueryRequest.of(i -> i.index("patent").query(query));
+        try {
+            client.updateByQuery(request);
+            return 1;
+        } catch (IOException e) {
+            return -1;
+        }
+    }
+
+    public Integer edit(Patent patent, String id,String routing) {
+        UpdateRequest<Patent, Patent> request = UpdateRequest.of(
+                i -> i.index("patent")
+                .id(id)
+                .routing(routing)
+                .doc(patent));
+        try {
+            client.update(request,Patent.class);
+            return 1;
+        } catch (IOException e) {
+            return -1;
+        }
+    }
+
+
+    /**
+     * 删除申请人/权利人/发明人合并名称
+     *
+     * @param patent
+     * @param id
+     * @return
+     */
+    public Integer delSingleMerge(Patent patent, String id,Integer type, String name) {
+        String source = "";
+        if (type == 0) {
+            source = "if (ctx._source.merge_applicant != null) { ctx._source.merge_applicant.removeIf(item -> item.name == params.name); } if (ctx._source.merge_right_holder  != null) { ctx._source.merge_right_holder .removeIf(item -> item.name == params.name); }";
+        } else {
+            source = "if (ctx._source.merge_inventor != null) { ctx._source.merge_inventor.removeIf(item -> item.name == params.name); }";
+        }
+        String finalSource = source;
+        InlineScript inlineScript = InlineScript.of(i -> i.lang("painless").params("name", JsonData.of(name)).source(finalSource));
+        Script script = Script.of(i -> i.inline(inlineScript));
+        Query query = QueryBuilders.term(i -> i.field("_id").value(id));
+        UpdateByQueryRequest request = UpdateByQueryRequest.of(i -> i.index("patent").script(script).query(query));
+        try {
+            client.updateByQuery(request);
+            return 1;
+        } catch (IOException e) {
+            return -1;
+        }
+    }
 }

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

@@ -180,6 +180,15 @@ public class EsPatentService {
         return collect;
     }
 
+    //通用返回合并申请人、合并权利人、合并发明人
+    public List<String> loadMergeName(List<PatentMergePerson> list) {
+        List<String> collect = new ArrayList<>();
+        if (!CollectionUtils.isEmpty(list)) {
+            collect = list.stream().map(PatentMergePerson::getName).collect(Collectors.toList());
+        }
+        return collect;
+    }
+
     /**
      * 获得中国专利pdf全文
      *

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

@@ -142,7 +142,7 @@ public class EsProductPatentService {
         return response.hits().total().value();
     }
 
-//添加
+    //添加
     @Transactional(propagation = Propagation.REQUIRED, rollbackFor = Throwable.class)
     public String addProductPatent(String patentId, Integer productId) throws Exception {
         Patent patent = new Patent();
@@ -151,7 +151,7 @@ public class EsProductPatentService {
         patentJoin.setName("product");
         patent.setPatentJoin(patentJoin);
         patent.setProductId(productId);
-      String id=  esService.addChildPatent(patent,patentId);
+        String id=  esService.addChildPatent(patent,patentId);
         return id;
     }
 }

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

@@ -18,6 +18,7 @@ import cn.cslg.pas.controller.PatentController;
 import cn.cslg.pas.domain.es.FamilyPatent;
 import cn.cslg.pas.domain.es.Patent;
 import cn.cslg.pas.domain.es.PatentFamilyMessage;
+import cn.cslg.pas.service.business.MergePersonService;
 import cn.cslg.pas.service.business.ProductMarketDataService;
 import cn.cslg.pas.service.business.ReportTempleService;
 import cn.cslg.pas.service.business.es.EsCountService;
@@ -61,6 +62,8 @@ public class EventServiceTests {
     private EsPatentService patentService;
     @Autowired
     private EsCustomFieldService esCustomFieldService;
+    @Autowired
+    private MergePersonService mergePersonService;
 
 
     @Autowired