fixed mergedPerson

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

@@ -413,29 +413,57 @@ public class MergePersonService extends ServiceImpl<MergePersonMapper, MergePers
 
                             //权利人
                             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());
+                            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());
                                     }
                                 }
-
-                                patent.setMergeRightHolder(mergeRightHolders);
                             }
+                            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<>();
-                            if (!CollectionUtils.isEmpty(patent.getMergeInventor())) {
-                                mergeInventors = patent.getMergeInventor();
-
-                                for (PatentMergePerson mergeInventor : mergeInventors) {
-                                    if (mergeInventor.getName().equals(name)) {
-                                        mergeInventor.setName(vo.getName());
+                            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());
                                     }
                                 }
-
-                                patent.setMergeInventor(mergeInventors);
+                            }
+                            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);
@@ -500,69 +528,146 @@ public class MergePersonService extends ServiceImpl<MergePersonMapper, MergePers
         String condition = vo.getSearchQuery();
         String name = vo.getName();
 
+        List<String> conditionList = new ArrayList<>();
+        if (StringUtils.isNotEmpty(condition)) {
+            if (condition.contains("or")) {
+                String[] split = condition.split("or");
+                conditionList.addAll(Arrays.asList(split));
+            } else {
+                conditionList.add(condition);
+            }
+        }
+
+        List<GetEsAllPersonDTO> personDTOS = new ArrayList<>();
         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);
-            }
+        if (!CollectionUtils.isEmpty(conditionList)) {
+            for (String s : conditionList) {
+                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(s));
+                        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 {
-                queries.add(query2);
+                    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(s));
+                        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 {
+                        queries.add(query2);
+                    }
+                } else {
+                    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(s));
+                        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);
+                    }
+                }
+                Query bool = QueryBuilders.bool(i -> i.should(queries));
+                builder.query(bool);
+                //分页
+//        if (pageNum > 0 && pageSize > 0) {
+//            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();
+
+                for (Hit<Patent> hit : hits) {
+                    Patent esMess = hit.source();
+                    GetEsAllPersonDTO personDTO = new GetEsAllPersonDTO();
+                    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);
+                }
             }
         } else {
-            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);
+            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 {
+                    queries.add(query2);
+                }
             } else {
-                queries.add(query);
+                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);
+                }
             }
-        }
-        Query bool = QueryBuilders.bool(i -> i.should(queries));
-        builder.query(bool);
-        //分页
+            Query bool = QueryBuilders.bool(i -> i.should(queries));
+            builder.query(bool);
+            //分页
 //        if (pageNum > 0 && pageSize > 0) {
 //            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();
-            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()));
+            SearchResponse<Patent> response = client.search(builder.build(), Patent.class);
+            List<Hit<Patent>> hits = response.hits().hits();
+
+            for (Hit<Patent> hit : hits) {
+                Patent esMess = hit.source();
+                GetEsAllPersonDTO personDTO = new GetEsAllPersonDTO();
+                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);
             }
-            personDTOS.add(personDTO);
         }
 
+
+
         //es申请人/权利人
         List<GetAllPersonDTO> personDTOList = new ArrayList<>();
         List<String> mergeList = new ArrayList<>();
@@ -645,7 +750,6 @@ public class MergePersonService extends ServiceImpl<MergePersonMapper, MergePers
             //设置查询索引
             builder.index("patent");
             List<Query> queries = new ArrayList<>();
-            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("merge_applicat").query(q1));
@@ -653,21 +757,12 @@ public class MergePersonService extends ServiceImpl<MergePersonMapper, MergePers
                 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_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);
-                mustQueries.add(query4);
             } else {
                 Query q = QueryBuilders.term(i -> i.field("inventor.name.key").value(delName));
                 Query query = QueryBuilders.nested(i -> i.path("inventor").query(q));
                 queries.add(query);
-                Query q1 = QueryBuilders.term(i -> i.field("merge_inventor.name.raw").value(name));
-                Query query1 = QueryBuilders.nested(i -> i.path("merge_inventor").query(q1));
-                queries.add(query1);
             }
-            Query query = QueryBuilders.bool(i -> i.must(mustQueries).should(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();
@@ -680,7 +775,110 @@ public class MergePersonService extends ServiceImpl<MergePersonMapper, MergePers
             if (!CollectionUtils.isEmpty(map)) {
                 for (String id : map.keySet()) {
                     Patent patent = map.get(id);
-                    this.delSingleMerge(patent, id, type, mergePerson.getName());
+                    List<PatentMergePerson> mergePersonList = new ArrayList<>();
+                    if (type == 0) {
+                        if (!CollectionUtils.isEmpty(patent.getApplicant())) {
+                            List<PatentPerson> applicant = patent.getApplicant();
+                            for (PatentPerson patentPerson : applicant) {
+                                PatentMergePerson merge = new PatentMergePerson();
+                                merge.setName(delName);
+                                merge.setType(patentPerson.getType());
+                                merge.setOrder(patentPerson.getOrder());
+                                merge.setProjectId(String.valueOf(projectId));
+                                mergePersonList.add(merge);
+                            }
+                        }
+                        if (CollectionUtils.isEmpty(mergePersonList)) {
+                            List<PatentPerson> rightHolder = patent.getRightHolder();
+                            for (PatentPerson patentPerson : rightHolder) {
+                                PatentMergePerson merge = new PatentMergePerson();
+                                merge.setName(delName);
+                                merge.setType(patentPerson.getType());
+                                merge.setOrder(patentPerson.getOrder());
+                                merge.setProjectId(String.valueOf(projectId));
+                                mergePersonList.add(merge);
+                            }
+                        }
+                    } else {
+                        List<PatentPerson> inventor = patent.getInventor();
+                        for (PatentPerson patentPerson : inventor) {
+                            PatentMergePerson merge = new PatentMergePerson();
+                            merge.setName(delName);
+                            merge.setType(patentPerson.getType());
+                            merge.setOrder(patentPerson.getOrder());
+                            merge.setProjectId(String.valueOf(projectId));
+                            mergePersonList.add(merge);
+                        }
+                    }
+
+                    if (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());
+                            }
+                        } 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());
+                            }
+                        } 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());
+                            }
+                        } catch (Exception e) {
+                        }
+                    }
+                    this.editMergePerson(patent, id);
+
+//                    this.delSingleMerge(patent, mergePersonList, id, type, mergePerson.getName());
                 }
             }
         }
@@ -840,7 +1038,7 @@ public class MergePersonService extends ServiceImpl<MergePersonMapper, MergePers
      * @param id
      * @return
      */
-    public Integer delSingleMerge(Patent patent, String id,Integer type, String name) {
+    public Integer delSingleMerge(Patent patent,List<PatentMergePerson> mergePersonList, 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); }";