fixed:合并

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

@@ -183,7 +183,7 @@ public class MergePersonService extends ServiceImpl<MergePersonMapper, MergePers
                                 Patent newPatent = new Patent();
                                 PatentJoin patentJoin = new PatentJoin();
                                 patentJoin.setParent(id);
-                                patentJoin.setName("merge_applicant");
+                                patentJoin.setName("merge_applicat");
                                 newPatent.setPatentJoin(patentJoin);
                                 newPatent.setMergeApplicant(appMergeList);
                                 String child = this.addChild(newPatent, id);
@@ -740,7 +740,7 @@ public class MergePersonService extends ServiceImpl<MergePersonMapper, MergePers
     }
 
     @Transactional(propagation = Propagation.REQUIRED, rollbackFor = Throwable.class)
-    public Integer delMergedName(MergedNameVO vo) throws IOException {
+    public Integer delMergedName(MergedNameVO vo) throws Exception {
         Integer type = vo.getType();
         //要移除的名字
         String delName = vo.getDelName();
@@ -768,16 +768,27 @@ public class MergePersonService extends ServiceImpl<MergePersonMapper, MergePers
             builder.index("patent");
             List<Query> queries = new ArrayList<>();
             if (type == 0) {
-                Query q1 = QueryBuilders.term(i -> i.field("applicant.name.key").value(delName));
-                Query query1 = QueryBuilders.nested(i -> i.path("merge_applicat").query(q1));
-                Query q2 = QueryBuilders.term(i -> i.field("right_holder.name.key").value(delName));
-                Query query2 = QueryBuilders.nested(i -> i.path("right_holder").query(q2));
-                queries.add(query1);
-                queries.add(query2);
+                //合并申请人
+                Query idQ1 = QueryBuilders.term(i -> i.field("merge_applicant.project_id").value(projectId));
+                Query q1 = QueryBuilders.term(i -> i.field("merge_applicant.name.raw").value(name));
+                Query bool = QueryBuilders.bool(i -> i.must(idQ1, q1));
+                Query query1 = QueryBuilders.nested(i -> i.path("merge_applicant").query(bool));
+                Query childQ1 = QueryBuilders.hasChild(i -> i.type("merge_applicat").query(query1));
+                //合并权利人
+                Query idQ2 = QueryBuilders.term(i -> i.field("merge_right_holder.project_id").value(projectId));
+                Query q2 = QueryBuilders.term(i -> i.field("merge_right_holder.name.raw").value(name));
+                Query bool1 = QueryBuilders.bool(i -> i.must(idQ2, q2));
+                Query query2 = QueryBuilders.nested(i -> i.path("merge_right_holder").query(bool1));
+                Query childQ2 = QueryBuilders.hasChild(i -> i.type("merge_right_holder").query(query2));
+                queries.add(childQ1);
+                queries.add(childQ2);
             } else {
-                Query q = QueryBuilders.term(i -> i.field("inventor.name.key").value(delName));
-                Query query = QueryBuilders.nested(i -> i.path("inventor").query(q));
-                queries.add(query);
+                Query idQ = QueryBuilders.term(i -> i.field("merge_inventor.project_id").value(projectId));
+                Query q = QueryBuilders.term(i -> i.field("merge_inventor.name.raw").value(name));
+                Query bool = QueryBuilders.bool(i -> i.must(idQ, q));
+                Query query = QueryBuilders.nested(i -> i.path("merge_inventor").query(bool));
+                Query childQ = QueryBuilders.hasChild(i -> i.type("merge_inventor").query(query));
+                queries.add(childQ);
             }
             Query query = QueryBuilders.bool(i -> i.should(queries));
             builder.query(query);
@@ -796,35 +807,53 @@ public class MergePersonService extends ServiceImpl<MergePersonMapper, MergePers
                     if (type == 0) {
                         if (!CollectionUtils.isEmpty(patent.getApplicant())) {
                             List<PatentPerson> applicant = patent.getApplicant();
-                            for (PatentPerson patentPerson : applicant) {
-                                PatentMergePerson merge = new PatentMergePerson();
-                                merge.setName(delName);
-                                merge.setType(patentPerson.getType());
-                                merge.setOrder(patentPerson.getOrder());
-                                merge.setProjectId(String.valueOf(projectId));
-                                mergePersonList.add(merge);
+                            List<String> collect = applicant.stream().map(PatentPerson::getName).collect(Collectors.toList());
+                            if (collect.contains(delName)) {
+                                for (PatentPerson patentPerson : applicant) {
+                                    if (delName.equals(patentPerson.getName())) {
+                                        PatentMergePerson merge = new PatentMergePerson();
+                                        merge.setName(delName);
+                                        merge.setType(patentPerson.getType());
+                                        merge.setOrder(patentPerson.getOrder());
+                                        merge.setProjectId(String.valueOf(projectId));
+                                        mergePersonList.add(merge);
+                                    }
+                                }
                             }
+
                         }
-                        if (CollectionUtils.isEmpty(mergePersonList)) {
+                        if (CollectionUtils.isEmpty(mergePersonList) && !CollectionUtils.isEmpty(patent.getRightHolder())) {
                             List<PatentPerson> rightHolder = patent.getRightHolder();
-                            for (PatentPerson patentPerson : rightHolder) {
-                                PatentMergePerson merge = new PatentMergePerson();
-                                merge.setName(delName);
-                                merge.setType(patentPerson.getType());
-                                merge.setOrder(patentPerson.getOrder());
-                                merge.setProjectId(String.valueOf(projectId));
-                                mergePersonList.add(merge);
+                            List<String> collect = rightHolder.stream().map(PatentPerson::getName).collect(Collectors.toList());
+                            if (collect.contains(delName)) {
+                                for (PatentPerson patentPerson : rightHolder) {
+                                    if (delName.equals(patentPerson.getName())) {
+                                        PatentMergePerson merge = new PatentMergePerson();
+                                        merge.setName(delName);
+                                        merge.setType(patentPerson.getType());
+                                        merge.setOrder(patentPerson.getOrder());
+                                        merge.setProjectId(String.valueOf(projectId));
+                                        mergePersonList.add(merge);
+                                    }
+                                }
                             }
                         }
                     } else {
-                        List<PatentPerson> inventor = patent.getInventor();
-                        for (PatentPerson patentPerson : inventor) {
-                            PatentMergePerson merge = new PatentMergePerson();
-                            merge.setName(delName);
-                            merge.setType(patentPerson.getType());
-                            merge.setOrder(patentPerson.getOrder());
-                            merge.setProjectId(String.valueOf(projectId));
-                            mergePersonList.add(merge);
+                        if (!CollectionUtils.isEmpty(patent.getInventor())) {
+                            List<PatentPerson> inventor = patent.getInventor();
+                            List<String> collect = inventor.stream().map(PatentPerson::getName).collect(Collectors.toList());
+                            if (collect.contains(delName)) {
+                                for (PatentPerson patentPerson : inventor) {
+                                    if (delName.equals(patentPerson.getName())) {
+                                        PatentMergePerson merge = new PatentMergePerson();
+                                        merge.setName(delName);
+                                        merge.setType(patentPerson.getType());
+                                        merge.setOrder(patentPerson.getOrder());
+                                        merge.setProjectId(String.valueOf(projectId));
+                                        mergePersonList.add(merge);
+                                    }
+                                }
+                            }
                         }
                     }
 
@@ -833,46 +862,84 @@ public class MergePersonService extends ServiceImpl<MergePersonMapper, MergePers
                         Map<String, List<PatentMergePerson>> appMap = this.getChildMergePerson(id, projectId, "merge_applicant");
                         if (!CollectionUtils.isEmpty(appMap)) {
                             for (String appId : appMap.keySet()) {
-                                List<PatentMergePerson> appList = appMap.get(appId);
-                                List<String> collect = appList.stream().map(PatentMergePerson::getName).collect(Collectors.toList());
-                                if (collect.contains(name)) {
-                                    this.add(appId, type, mergePersonList);
-                                }
                                 if (CollectionUtils.isEmpty(nameDatas)) {
                                     this.delSingleMerge(appId, type, name);
                                 }
+
+                                List<PatentMergePerson> appMergeList = new ArrayList<>(mergePersonList);
+                                List<PatentMergePerson> appList = appMap.get(appId);
+                                appMergeList.addAll(appList);
+                                //添加子文档
+                                Patent newPatent = new Patent();
+                                PatentJoin patentJoin = new PatentJoin();
+                                patentJoin.setParent(id);
+                                patentJoin.setName("merge_applicat");
+                                newPatent.setPatentJoin(patentJoin);
+                                newPatent.setMergeApplicant(appMergeList);
+                                String child = this.addChild(newPatent, id);
+                                if (StringUtils.isEmpty(child)) {
+                                    throw new XiaoShiException("移除失败");
+                                } else {
+                                    //删除原子文档
+                                    this.delete(Arrays.asList(appId));
+                                }
                             }
                         }
                         //权利人
                         Map<String, List<PatentMergePerson>> rightMap = this.getChildMergePerson(id, projectId, "merge_right_holder");
                         if (!CollectionUtils.isEmpty(rightMap)) {
                             for (String rightId : rightMap.keySet()) {
-                                List<PatentMergePerson> rightList = rightMap.get(rightId);
-                                List<String> collect = rightList.stream().map(PatentMergePerson::getName).collect(Collectors.toList());
-                                if (collect.contains(name)) {
-                                    this.add(rightId, type, mergePersonList);
-                                }
                                 if (CollectionUtils.isEmpty(nameDatas)) {
                                     this.delSingleMerge(rightId, type, name);
                                 }
+
+                                ArrayList<PatentMergePerson> rightMergeList = new ArrayList<>(mergePersonList);
+                                List<PatentMergePerson> rightList = rightMap.get(rightId);
+                                rightMergeList.addAll(rightList);
+                                //添加子文档
+                                Patent newPatent = new Patent();
+                                PatentJoin patentJoin = new PatentJoin();
+                                patentJoin.setParent(id);
+                                patentJoin.setName("merge_right_holder");
+                                newPatent.setPatentJoin(patentJoin);
+                                newPatent.setMergeRightHolder(rightMergeList);
+                                String child = this.addChild(newPatent, id);
+                                if (StringUtils.isEmpty(child)) {
+                                    throw new XiaoShiException("移除失败");
+                                } else {
+                                    //删除原子文档
+                                    this.delete(Arrays.asList(rightId));
+                                }
                             }
                         }
                     } else if (type == 2) {
                         Map<String, List<PatentMergePerson>> inventorMap = this.getChildMergePerson(id, projectId, "merge_inventor");
                         if (!CollectionUtils.isEmpty(inventorMap)) {
                             for (String inventorId : inventorMap.keySet()) {
-                                List<PatentMergePerson> inventorList = inventorMap.get(inventorId);
-                                List<String> collect = inventorList.stream().map(PatentMergePerson::getName).collect(Collectors.toList());
-                                if (collect.contains(name)) {
-                                    this.add(inventorId, type, mergePersonList);
-                                }
                                 if (CollectionUtils.isEmpty(nameDatas)) {
                                     this.delSingleMerge(inventorId, type, mergedName);
                                 }
+
+                                ArrayList<PatentMergePerson> inventorMergeList = new ArrayList<>(mergePersonList);
+                                List<PatentMergePerson> inventorList = inventorMap.get(inventorId);
+                                inventorMergeList.addAll(inventorList);
+                                //添加子文档
+                                Patent newPatent = new Patent();
+                                PatentJoin patentJoin = new PatentJoin();
+                                patentJoin.setParent(id);
+                                patentJoin.setName("merge_inventor");
+                                newPatent.setPatentJoin(patentJoin);
+                                newPatent.setMergeInventor(inventorMergeList);
+                                String child = this.addChild(newPatent, id);
+                                if (StringUtils.isEmpty(child)) {
+                                    throw new XiaoShiException("移除失败");
+                                } else {
+                                    //删除原子文档
+                                    this.delete(Arrays.asList(inventorId));
+                                }
                             }
                         }
                     }
-
                 }
             } else {
                 throw new XiaoShiException("移除失败");
@@ -882,11 +949,14 @@ public class MergePersonService extends ServiceImpl<MergePersonMapper, MergePers
     }
 
     @Transactional(propagation = Propagation.REQUIRED, rollbackFor = Throwable.class)
-    public Integer delMergePerson(MergePersonIdVO vo) throws IOException {
+    public Integer delMergePerson(MergePersonIdVO vo) throws Exception {
         Integer type = vo.getType();
         MergePerson mergePerson = mergePersonMapper.selectById(vo.getId());
+        //合并后的名称
         String name = mergePerson.getName();
+        //专题库id
         Integer projectId = mergePerson.getProjectId();
+        //合并的名称
         String mergedName = mergePerson.getMergedName();
         if (ObjectUtil.isNotEmpty(mergePerson)) {
             LambdaQueryWrapper<MergePerson> wrapper = new LambdaQueryWrapper<MergePerson>()
@@ -952,7 +1022,7 @@ public class MergePersonService extends ServiceImpl<MergePersonMapper, MergePers
 
                                 }
                             }
-                            if (CollectionUtils.isEmpty(mergePersonList)) {
+                            if (!CollectionUtils.isEmpty(patent.getRightHolder()) && list.size() != mergePersonList.size()) {
                                 List<PatentPerson> rightHolder = patent.getRightHolder();
                                 for (PatentPerson patentPerson : rightHolder) {
                                     if (list.contains(patentPerson.getName())) {
@@ -963,19 +1033,20 @@ public class MergePersonService extends ServiceImpl<MergePersonMapper, MergePers
                                         merge.setProjectId(String.valueOf(projectId));
                                         mergePersonList.add(merge);
                                     }
-
                                 }
                             }
                         } else {
-                            List<PatentPerson> inventor = patent.getInventor();
-                            for (PatentPerson patentPerson : inventor) {
-                                if (list.contains(patentPerson.getName())) {
-                                    PatentMergePerson merge = new PatentMergePerson();
-                                    merge.setName(patentPerson.getName());
-                                    merge.setType(patentPerson.getType());
-                                    merge.setOrder(patentPerson.getOrder());
-                                    merge.setProjectId(String.valueOf(projectId));
-                                    mergePersonList.add(merge);
+                            if (!CollectionUtils.isEmpty(patent.getInventor())) {
+                                List<PatentPerson> inventor = patent.getInventor();
+                                for (PatentPerson patentPerson : inventor) {
+                                    if (list.contains(patentPerson.getName())) {
+                                        PatentMergePerson merge = new PatentMergePerson();
+                                        merge.setName(patentPerson.getName());
+                                        merge.setType(patentPerson.getType());
+                                        merge.setOrder(patentPerson.getOrder());
+                                        merge.setProjectId(String.valueOf(projectId));
+                                        mergePersonList.add(merge);
+                                    }
                                 }
                             }
                         }
@@ -985,21 +1056,71 @@ public class MergePersonService extends ServiceImpl<MergePersonMapper, MergePers
                             Map<String, List<PatentMergePerson>> appMap = this.getChildMergePerson(id, projectId, "merge_applicant");
                             if (!CollectionUtils.isEmpty(appMap)) {
                                 for (String appId : appMap.keySet()) {
-                                    this.add(appId, type, mergePersonList);
+                                    List<PatentMergePerson> appMergeList = new ArrayList<>(mergePersonList);
+                                    List<PatentMergePerson> appList = appMap.get(appId);
+                                    appMergeList.addAll(appList);
+                                    //添加子文档
+                                    Patent newPatent = new Patent();
+                                    PatentJoin patentJoin = new PatentJoin();
+                                    patentJoin.setParent(id);
+                                    patentJoin.setName("merge_applicat");
+                                    newPatent.setPatentJoin(patentJoin);
+                                    newPatent.setMergeApplicant(appMergeList);
+                                    String child = this.addChild(newPatent, id);
+                                    if (StringUtils.isEmpty(child)) {
+                                        throw new XiaoShiException("删除失败");
+                                    } else {
+                                        //删除原子文档
+                                        this.delete(Arrays.asList(appId));
+                                    }
                                 }
                             }
+
+
                             //权利人
                             Map<String, List<PatentMergePerson>> rightMap = this.getChildMergePerson(id, projectId, "merge_right_holder");
                             if (!CollectionUtils.isEmpty(rightMap)) {
                                 for (String rightId : rightMap.keySet()) {
-                                    this.add(rightId, type, mergePersonList);
+                                    ArrayList<PatentMergePerson> rightMergeList = new ArrayList<>(mergePersonList);
+                                    List<PatentMergePerson> rightList = rightMap.get(rightId);
+                                    rightMergeList.addAll(rightList);
+                                    //添加子文档
+                                    Patent newPatent = new Patent();
+                                    PatentJoin patentJoin = new PatentJoin();
+                                    patentJoin.setParent(id);
+                                    patentJoin.setName("merge_right_holder");
+                                    newPatent.setPatentJoin(patentJoin);
+                                    newPatent.setMergeRightHolder(rightMergeList);
+                                    String child = this.addChild(newPatent, id);
+                                    if (StringUtils.isEmpty(child)) {
+                                        throw new XiaoShiException("删除失败");
+                                    } else {
+                                        //删除原子文档
+                                        this.delete(Arrays.asList(rightId));
+                                    }
                                 }
                             }
                         } else if (type == 2) {
                             Map<String, List<PatentMergePerson>> inventorMap = this.getChildMergePerson(id, projectId, "merge_inventor");
                             if (!CollectionUtils.isEmpty(inventorMap)) {
                                 for (String inventorId : inventorMap.keySet()) {
-                                    this.add(inventorId, type, mergePersonList);
+                                    ArrayList<PatentMergePerson> inventorMergeList = new ArrayList<>(mergePersonList);
+                                    List<PatentMergePerson> inventorList = inventorMap.get(inventorId);
+                                    inventorMergeList.addAll(inventorList);
+                                    //添加子文档
+                                    Patent newPatent = new Patent();
+                                    PatentJoin patentJoin = new PatentJoin();
+                                    patentJoin.setParent(id);
+                                    patentJoin.setName("merge_inventor");
+                                    newPatent.setPatentJoin(patentJoin);
+                                    newPatent.setMergeInventor(inventorMergeList);
+                                    String child = this.addChild(newPatent, id);
+                                    if (StringUtils.isEmpty(child)) {
+                                        throw new XiaoShiException("删除失败");
+                                    } else {
+                                        //删除原子文档
+                                        this.delete(Arrays.asList(inventorId));
+                                    }
                                 }
                             }
                         }