Merge remote-tracking branch 'origin/master'

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

@@ -166,70 +166,56 @@ public class MergePersonService extends ServiceImpl<MergePersonMapper, MergePers
             mergePersonList.add(mergePerson);
 
             for (String id : map.keySet()) {
-                Patent patent = map.get(id);
                 if (type == 0) {
                     //申请人
-                    List<PatentMergePerson> mergeApplicants = new ArrayList<>();
-                    List<PatentMergePerson> mergeApplicant = this.getChildMergePerson(id, projectId, "merge_applicant");
-                    if (!CollectionUtils.isEmpty(mergeApplicant)) {
-                        for (String mergedName : mergedNames) {
-                            mergeApplicant.removeIf(app -> app.getName().equals(mergedName));
+                    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(vo.getName())) {
+                                for (String mergedName : mergedNames) {
+                                    this.delSingleMerge(appId, type, mergedName);
+                                }
+                                this.add(appId, type, mergePersonList);
+                            }
                         }
                     }
-                    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> mergeRightHolders = new ArrayList<>();
-                    List<PatentMergePerson> mergeRightHolder = this.getChildMergePerson(id, projectId, "merge_right_holder");
-                    if (!CollectionUtils.isEmpty(patent.getMergeRightHolder())) {
-                        for (String mergedName : mergedNames) {
-                            mergeRightHolder.removeIf(right -> right.getName().equals(mergedName));
+                    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(vo.getName())) {
+                                for (String mergedName : mergedNames) {
+                                    this.delSingleMerge(rightId, type, mergedName);
+                                }
+                                this.add(rightId, type, mergePersonList);
+                            }
                         }
                     }
-                    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) {
-                    }
                 } else if (type == 2) {
-                    List<PatentMergePerson> mergeInventors = new ArrayList<>();
-                    List<PatentMergePerson> mergeInventor = this.getChildMergePerson(id, projectId, "merge_inventor");
-                    if (!CollectionUtils.isEmpty(patent.getMergeInventor())) {
-                        for (String mergedName : mergedNames) {
-                            mergeInventor.removeIf(inventor -> inventor.getName().equals(mergedName));
+                    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(vo.getName())) {
+                                for (String mergedName : mergedNames) {
+                                    this.delSingleMerge(inventorId, type, mergedName);
+                                }
+                                this.add(inventorId, type, mergePersonList);
+                            }
                         }
                     }
-                    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) {
-                    }
                 }
             }
         }
         return person.getId();
     }
 
-    public List<PatentMergePerson> getChildMergePerson(String id, Integer projectId, String mergeType) throws IOException {
-        List<PatentMergePerson> list = new ArrayList<>();
+    public Map<String, List<PatentMergePerson>> getChildMergePerson(String id, Integer projectId, String mergeType) throws IOException {
         String path = mergeType + "." + "project_id";
         SearchRequest.Builder builder = new SearchRequest.Builder();
         //设置查询索引
@@ -240,13 +226,28 @@ public class MergePersonService extends ServiceImpl<MergePersonMapper, MergePers
         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);
+
+        SearchResponse<Patent> response = client.search(builder.build(), Patent.class);
+        List<Hit<Patent>> hits = response.hits().hits();
+        Map<String, List<PatentMergePerson>> map = new HashMap<>();
+        for (Hit<Patent> hit : hits) {
+            String id1 = hit.id();
+            Patent patent = hit.source();
+            if (mergeType.equals("merge_applicat")) {
+                if (!CollectionUtils.isEmpty(patent.getMergeApplicant())) {
+                    map.put(id1, patent.getMergeApplicant());
+                }
+            } else if (mergeType.equals("merge_right_holder")) {
+                if (!CollectionUtils.isEmpty(patent.getMergeRightHolder())) {
+                    map.put(id1, patent.getMergeRightHolder());
+                }
+            } else {
+                if (!CollectionUtils.isEmpty(patent.getMergeInventor())) {
+                    map.put(id1, patent.getMergeInventor());
+                }
+            }
         }
-        return list;
+        return map;
     }
 
     public List<EsMergePersonDTO> getChildMergePersonDTO(String id, Integer projectId, String mergeType) throws IOException {
@@ -367,6 +368,7 @@ public class MergePersonService extends ServiceImpl<MergePersonMapper, MergePers
                     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 bool = QueryBuilders.bool(i -> i.must(idQ, q));
                     Query childQ = QueryBuilders.hasChild(i -> i.type("merge_inventor").query(query));
                     queries.add(childQ);
                 }
@@ -382,91 +384,30 @@ public class MergePersonService extends ServiceImpl<MergePersonMapper, MergePers
 
                 if (!CollectionUtils.isEmpty(map)) {
                     for (String id : map.keySet()) {
-                        Patent patent = map.get(id);
                         if (type == 0) {
                             //申请人
-                            List<PatentMergePerson> mergeApplicants = new ArrayList<>();
-                            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());
-                                    }
-                                }
-                            }
-                            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());
+                            Map<String, List<PatentMergePerson>> appMap = this.getChildMergePerson(id, projectId, "merge_applicant");
+                            if (!CollectionUtils.isEmpty(appMap)) {
+                                for (String appId : appMap.keySet()) {
+                                    this.edit(appId, type, name, vo.getName());
                                 }
-                            } catch (Exception e) {
                             }
 
                             //权利人
-                            List<PatentMergePerson> mergeRightHolders = new ArrayList<>();
-                            List<EsMergePersonDTO> mergeRightHolder = this.getChildMergePersonDTO(id, projectId, "merge_right_holder");
-                            if (!CollectionUtils.isEmpty(mergeRightHolder)) {
-                                for (EsMergePersonDTO right : mergeRightHolder) {
-                                    if (right.getName().equals(name)) {
-                                        right.setName(vo.getName());
-                                    }
+                            Map<String, List<PatentMergePerson>> rightMap = this.getChildMergePerson(id, projectId, "merge_right_holder");
+                            if (!CollectionUtils.isEmpty(rightMap)) {
+                                for (String rightId : rightMap.keySet()) {
+                                    this.edit(rightId, type, name, vo.getName());
                                 }
                             }
-                            for (EsMergePersonDTO dto : mergeRightHolder) {
-                                PatentMergePerson per = new PatentMergePerson();
-                                BeanUtils.copyProperties(dto, per);
-                                mergeRightHolders.add(per);
-                            }
-                            patent.setMergeRightHolder(mergeRightHolders);
-                            PatentJoin join = new PatentJoin();
-                            join.setParent(id);
-                            join.setName("merge_right_holder");
-                            patent.setPatentJoin(join);
-                            try {
-                                for (EsMergePersonDTO dto : mergeRightHolder) {
-                                    this.edit(patent, dto.getId(), dto.getRouting());
-                                }
-                            } catch (Exception e) {
-                            }
-
-
                         } else if (type == 2) {
-                            List<PatentMergePerson> mergeInventors = new ArrayList<>();
-                            List<EsMergePersonDTO> mergeInventor = this.getChildMergePersonDTO(id, projectId, "merge_inventor");
-                            if (!CollectionUtils.isEmpty(mergeInventor)) {
-                                for (EsMergePersonDTO inventor : mergeInventor) {
-                                    if (inventor.getName().equals(name)) {
-                                        inventor.setName(vo.getName());
-                                    }
+                            Map<String, List<PatentMergePerson>> inventorMap = this.getChildMergePerson(id, projectId, "merge_inventor");
+                            if (!CollectionUtils.isEmpty(inventorMap)) {
+                                for (String inventorId : inventorMap.keySet()) {
+                                    this.edit(inventorId, type, name, vo.getName());
                                 }
                             }
-                            for (EsMergePersonDTO dto : mergeInventor) {
-                                PatentMergePerson per = new PatentMergePerson();
-                                BeanUtils.copyProperties(dto, per);
-                                mergeInventors.add(per);
-                            }
-                            patent.setMergeInventor(mergeInventors);
-                            PatentJoin join = new PatentJoin();
-                            join.setParent(id);
-                            join.setName("merge_right_holder");
-                            patent.setPatentJoin(join);
-                            try {
-                                for (EsMergePersonDTO dto : mergeInventor) {
-                                    this.edit(patent, dto.getId(), dto.getRouting());
-                                }
-                            } catch (Exception e) {
-                            }
                         }
-                        this.editMergePerson(patent, id);
                     }
                 }
             }
@@ -701,10 +642,10 @@ public class MergePersonService extends ServiceImpl<MergePersonMapper, MergePers
 
         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);
+            MergePerson person = mergePersonMapper.selectOne(new LambdaQueryWrapper<MergePerson>()
+                    .eq(MergePerson::getName, key));
             if (ObjectUtils.isNotEmpty(person)) {
                 dto.setMergeId(person.getId());
                 dto.setType(person.getType());
@@ -731,7 +672,9 @@ public class MergePersonService extends ServiceImpl<MergePersonMapper, MergePers
     @Transactional(propagation = Propagation.REQUIRED, rollbackFor = Throwable.class)
     public Integer delMergedName(MergedNameVO vo) throws IOException {
         Integer type = vo.getType();
+        //要移除的名字
         String delName = vo.getDelName();
+        //合并后的名称
         String name = vo.getName();
         Integer projectId = vo.getProjectId();
         MergePerson mergePerson = mergePersonMapper.selectOne(new LambdaQueryWrapper<MergePerson>()
@@ -746,6 +689,10 @@ public class MergePersonService extends ServiceImpl<MergePersonMapper, MergePers
             person.setMergedName(JSONArray.toJSONString(list));
             person.updateById();
 
+            //移除后最后剩下的名称
+            String finalMergedName = person.getMergedName();
+            List<String> nameDatas = JSONArray.parseArray(finalMergedName, String.class);
+
             SearchRequest.Builder builder = new SearchRequest.Builder();
             //设置查询索引
             builder.index("patent");
@@ -813,72 +760,49 @@ public class MergePersonService extends ServiceImpl<MergePersonMapper, MergePers
 
                     if (type == 0) {
                         //申请人
-                        List<PatentMergePerson> mergeApplicants = new ArrayList<>();
-                        List<EsMergePersonDTO> mergeApplicant = this.getChildMergePersonDTO(id, projectId, "merge_applicant");
-                        for (EsMergePersonDTO dto : mergeApplicant) {
-                            PatentMergePerson per = new PatentMergePerson();
-                            BeanUtils.copyProperties(dto, per);
-                            mergeApplicants.add(per);
-                        }
-                        mergeApplicants.addAll(mergePersonList);
-                        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());
+                        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);
+                                }
                             }
-                        } catch (Exception e) {
                         }
-
                         //权利人
-                        List<PatentMergePerson> mergeRightHolders = new ArrayList<>();
-                        List<EsMergePersonDTO> mergeRightHolder = this.getChildMergePersonDTO(id, projectId, "merge_right_holder");
-                        for (EsMergePersonDTO dto : mergeRightHolder) {
-                            PatentMergePerson per = new PatentMergePerson();
-                            BeanUtils.copyProperties(dto, per);
-                            mergeRightHolders.add(per);
-                        }
-                        mergeRightHolders.addAll(mergePersonList);
-                        patent.setMergeRightHolder(mergeRightHolders);
-                        PatentJoin join = new PatentJoin();
-                        join.setParent(id);
-                        join.setName("merge_right_holder");
-                        patent.setPatentJoin(join);
-                        try {
-                            for (EsMergePersonDTO dto : mergeRightHolder) {
-                                this.edit(patent, dto.getId(), dto.getRouting());
+                        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);
+                                }
                             }
-                        } catch (Exception e) {
                         }
-
-
                     } else if (type == 2) {
-                        List<PatentMergePerson> mergeInventors = new ArrayList<>();
-                        List<EsMergePersonDTO> mergeInventor = this.getChildMergePersonDTO(id, projectId, "merge_inventor");
-                        for (EsMergePersonDTO dto : mergeInventor) {
-                            PatentMergePerson per = new PatentMergePerson();
-                            BeanUtils.copyProperties(dto, per);
-                            mergeInventors.add(per);
-                        }
-                        mergeInventors.addAll(mergePersonList);
-                        patent.setMergeInventor(mergeInventors);
-                        PatentJoin join = new PatentJoin();
-                        join.setParent(id);
-                        join.setName("merge_right_holder");
-                        patent.setPatentJoin(join);
-                        try {
-                            for (EsMergePersonDTO dto : mergeInventor) {
-                                this.edit(patent, dto.getId(), dto.getRouting());
+                        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);
+                                }
                             }
-                        } catch (Exception e) {
                         }
                     }
-                    this.editMergePerson(patent, id);
 
-//                    this.delSingleMerge(patent, mergePersonList, id, type, mergePerson.getName());
                 }
             }
         }
@@ -899,6 +823,7 @@ public class MergePersonService extends ServiceImpl<MergePersonMapper, MergePers
 
             List<String> list = JSONArray.parseArray(mergedName, String.class);
             if (!CollectionUtils.isEmpty(list)) {
+
                 SearchRequest.Builder builder = new SearchRequest.Builder();
                 //设置查询索引
                 builder.index("patent");
@@ -930,15 +855,85 @@ public class MergePersonService extends ServiceImpl<MergePersonMapper, MergePers
                 builder.query(query);
                 SearchResponse<Patent> response = client.search(builder.build(), Patent.class);
                 List<Hit<Patent>> hits = response.hits().hits();
-                List<String> ids = new ArrayList<>();
+                Map<String, Patent> map = new HashMap<>();
                 for (Hit<Patent> hit : hits) {
                     String id = hit.id();
-                    ids.add(id);
+                    map.put(id, hit.source());
                 }
 
-                if (!CollectionUtils.isEmpty(ids)) {
-                    this.delete(ids);
+                if (!CollectionUtils.isEmpty(map)) {
+                    for (String id : map.keySet()) {
+                        Patent patent = map.get(id);
+                        List<PatentMergePerson> mergePersonList = new ArrayList<>();
+                        if (type == 0) {
+                            if (!CollectionUtils.isEmpty(patent.getApplicant())) {
+                                List<PatentPerson> applicant = patent.getApplicant();
+                                for (PatentPerson patentPerson : applicant) {
+                                    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(mergePersonList)) {
+                                List<PatentPerson> rightHolder = patent.getRightHolder();
+                                for (PatentPerson patentPerson : rightHolder) {
+                                    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);
+                                    }
+
+                                }
+                            }
+                        } 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 (type == 0) {
+                            //申请人
+                            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);
+                                }
+                            }
+                            //权利人
+                            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);
+                                }
+                            }
+                        } 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);
+                                }
+                            }
+                        }
+                    }
                 }
+
             }
         }
         return vo.getId();
@@ -1034,11 +1029,10 @@ public class MergePersonService extends ServiceImpl<MergePersonMapper, MergePers
     /**
      * 删除申请人/权利人/发明人合并名称
      *
-     * @param patent
      * @param id
      * @return
      */
-    public Integer delSingleMerge(Patent patent,List<PatentMergePerson> mergePersonList, String id,Integer type, String name) {
+    public Integer delSingleMerge(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); }";
@@ -1057,4 +1051,50 @@ public class MergePersonService extends ServiceImpl<MergePersonMapper, MergePers
             return -1;
         }
     }
+
+
+    public Integer add(String id,Integer type,List<PatentMergePerson> mergePersonList) {
+        String source = "";
+        if (type == 0) {
+            source = "if (ctx._source.merge_applicant != null) {ctx._source.merge_applicant.add(params.data)} else { List list = new ArrayList();list.add(params.data);ctx._source.merge_applicant = list;}" +
+                    "if (ctx._source.merge_right_holder  != null) { ctx._source.merge_right_holder.add(params.data)} else { List list = new ArrayList();list.add(params.data);ctx._source.merge_right_holder = list;}";
+        } else {
+            source = "if (ctx._source.merge_inventor != null) {ctx._source.merge_inventor.add(params.data)} else { List list = new ArrayList();list.add(params.data);ctx._source.merge_inventor = list;}";
+        }
+        String finalSource = source;
+        InlineScript inlineScript = InlineScript.of(i -> i.lang("painless").params("data", JsonData.of(mergePersonList)).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;
+        }
+    }
+
+    public Integer edit(String id,Integer type,String oldName, String newName) {
+        String source = "";
+        if (type == 0) {
+            source = "if (ctx._source.merge_applicant != null) {for (item in ctx._source.merge_applicant) {if(item['name']==params.oldName){item['name']=params.newName}}}" +
+                    "if (ctx._source.merge_right_holder != null) {for (item in ctx._source.merge_right_holder) {if(item['name']==params.oldName){item['name']=params.newName}}}";
+        } else {
+            source = "if (ctx._source.merge_inventor != null) {for (item in ctx._source.merge_inventor) {if(item['name']==params.oldName){item['name']=params.newName}}}";
+        }
+        String finalSource = source;
+        Map<String, JsonData> map = new HashMap<>();
+        map.put("oldName", JsonData.of(oldName));
+        map.put("newName", JsonData.of(newName));
+        InlineScript inlineScript = InlineScript.of(i -> i.lang("painless").params(map).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;
+        }
+    }
 }