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

package cn.cslg.pas.service.business;

import cn.cslg.pas.common.dto.GetAllCountryDTO;
import cn.cslg.pas.common.dto.GetAllPersonDTO;
import cn.cslg.pas.common.dto.MergePersonQueryDTO;
import cn.cslg.pas.common.dto.PatentColumnDTO;
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;
import cn.cslg.pas.common.utils.CacheUtils;
import cn.cslg.pas.common.utils.LoginUtils;
import cn.cslg.pas.common.utils.parseQueryToTree.expressManager;
import cn.cslg.pas.common.utils.parseQueryToTree.operateNode;
import cn.cslg.pas.common.utils.parseQueryToTree.treeNode;
import cn.cslg.pas.common.vo.business.*;
import cn.cslg.pas.domain.BaseEntity;
import cn.cslg.pas.domain.business.FollowUp;
import cn.cslg.pas.domain.business.MergePerson;
import cn.cslg.pas.domain.business.SystemDict;
import cn.cslg.pas.domain.es.*;
import cn.cslg.pas.exception.UnLoginException;
import cn.cslg.pas.exception.XiaoShiException;
import cn.cslg.pas.mapper.MergePersonMapper;
import cn.cslg.pas.mapper.SystemDictMapper;
import cn.cslg.pas.service.business.es.EsPatentService;
import cn.cslg.pas.service.business.es.EsService;
import cn.cslg.pas.service.query.FormatQueryService;
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.*;
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;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
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;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Propagation;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.util.CollectionUtils;

import java.io.IOException;
import java.util.*;
import java.util.stream.Collectors;

/**
 * @Author xiexiang
 * @Date 2024/01/02
 */
@Slf4j
@Service
public class MergePersonService extends ServiceImpl<MergePersonMapper, MergePerson> {
    @Autowired
    private ElasticsearchClient client;
    @Autowired
    private CacheUtils cacheUtils;
    @Autowired
    private LoginUtils loginUtils;
    @Autowired
    private MergePersonMapper mergePersonMapper;
    @Autowired
    private FormatQueryService formatQueryService;
    @Autowired
    private EsPatentService esPatentService;
    @Autowired
    private EsService esService;
    @Autowired
    private SystemDictMapper systemDictMapper;

    /**
     * 专利列表上新增发明人/权利人/申请人合并
     *
     * @param vo
     * @return
     * @throws Exception
     */
    @Transactional(propagation = Propagation.REQUIRED, rollbackFor = Throwable.class)
    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 {
            personnelVO = cacheUtils.getLoginUser(loginUtils.getId());
        } catch (Exception e) {
            throw new XiaoShiException("未登录");
        }
        //判断是否名称重复
        LambdaQueryWrapper<MergePerson> wrapper = new LambdaQueryWrapper<MergePerson>()
                .eq(MergePerson::getProjectId, vo.getProjectId())
                .eq(MergePerson::getName, vo.getName());
        List<MergePerson> list = mergePersonMapper.selectList(wrapper);
        if (list.size() > 0) {
            throw new XiaoShiException("合并名称不可重复");
        }

        MergePerson person = new MergePerson();
        BeanUtils.copyProperties(vo, person);
        person.setMergedName(JSONArray.toJSONString(mergedNames));
        person.setCreateId(personnelVO.getId());
        person.setCreateTime(new Date());
        person.insert();

        SearchRequest.Builder builder = new SearchRequest.Builder();
        //设置查询索引
        builder.index("patent");

        List<Query> queries = new ArrayList<>();
        if (type == 0) {
            for (String mergedName : mergedNames) {
                //合并申请人
                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 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));
        builder.query(query);
        SearchResponse<Patent> response = client.search(builder.build(), Patent.class);
        List<Hit<Patent>> hits = response.hits().hits();
        Map<String, Patent> map = new HashMap<>();
        for (Hit<Patent> hit : hits) {
            String id = hit.id();
            map.put(id, hit.source());
        }

        if (!CollectionUtils.isEmpty(map)) {
            List<PatentMergePerson> mergePersonList = new ArrayList<>();
            PatentMergePerson mergePerson = new PatentMergePerson();
            mergePerson.setName(vo.getName());
            mergePerson.setProjectId(vo.getProjectId().toString());
            mergePerson.setType("1");
            mergePerson.setOrder(1);
            mergePersonList.add(mergePerson);

            for (String id : map.keySet()) {
                if (type == 0) {
                    //申请人
                    Map<String, List<PatentMergePerson>> appMap = this.getChildMergePerson(id, projectId, "merge_applicant");
                    if (!CollectionUtils.isEmpty(appMap)) {
                        for (String appId : appMap.keySet()) {
                            List<PatentMergePerson> appMergeList = new ArrayList<>(mergePersonList);
                            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) {
                                    appList.removeIf(i -> i.getName().equals(mergedName));
                                }
                                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> rightMergeList = new ArrayList<>(mergePersonList);
                            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) {
                                    rightList.removeIf(i -> i.getName().equals(mergedName));
                                }
                                rightMergeList.addAll(rightList);
                                //添加子文档
                                Patent newPatent = new Patent();
                                PatentJoin patentJoin = new PatentJoin();
                                patentJoin.setParent(id);
                                patentJoin.setName("merge_right_holder");
                                newPatent.setPatentJoin(patentJoin);
                                newPatent.setMergeInventor(rightMergeList);
                                String child = this.addChild(newPatent, id);
                                if (StringUtils.isEmpty(child)) {
                                    throw new XiaoShiException("合并失败");
                                } else {
                                    //删除原子文档
                                    this.delete(Arrays.asList(rightId));
                                }

//                                for (String mergedName : mergedNames) {
//                                    this.delSingleMerge(rightId, type, mergedName);
//                                }
//                                Integer num = this.add(rightId, type, mergePersonList);
//                                if (num < 0) {
//                                    throw new XiaoShiException("合并失败");
//                                }
                            }
                        }
                    }
                } 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> inventorMergeList = new ArrayList<>(mergePersonList);
                            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) {
                                    inventorList.removeIf(i -> i.getName().equals(mergedName));
                                }
                                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("合并失败");
        }
        return person.getId();
    }

    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();
        //设置查询索引
        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);

        builder.trackTotalHits(i -> i.enabled(true));
        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_applicant")) {
                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 map;
    }

    /**
     * 专利列表上再次新增发明人/权利人/申请人合并
     *
     * @param vo
     * @return
     * @throws Exception
     */
    @Transactional(propagation = Propagation.REQUIRED, rollbackFor = Throwable.class)
    public Integer mergePersonAgain(MergePersonAgainVO vo) throws Exception {
        List<String> mergedNames = vo.getNeedMergedName();
        List<String> mergeName = vo.getMergedName();
        Integer type = vo.getType();
        Integer projectId = vo.getProjectId();
        List<String> nameList = new ArrayList<>();
        if (!CollectionUtils.isEmpty(mergedNames)) {
            for (String mergedName : mergedNames) {
                MergePerson person = mergePersonMapper.selectOne(new LambdaQueryWrapper<MergePerson>()
                        .eq(MergePerson::getProjectId, vo.getProjectId())
                        .eq(MergePerson::getName, mergedName));
                String name = person.getMergedName();
                List<String> getNames = JSONArray.parseArray(name, String.class);
                nameList.addAll(getNames);

                Map<String, Patent> map = this.getDelPatent(type, projectId, mergedName);
                if (!CollectionUtils.isEmpty(map)) {
                    for (String id : map.keySet()) {
                        Patent patent = map.get(id);
                        List<PatentMergePerson> appPersonList = new ArrayList<>();
                        List<PatentMergePerson> rightPersonList = new ArrayList<>();
                        List<PatentMergePerson> inventorPersonList = 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(patentPerson.getName());
                                    merge.setType(patentPerson.getType());
                                    merge.setOrder(patentPerson.getOrder());
                                    merge.setProjectId(String.valueOf(projectId));
                                    appPersonList.add(merge);
                                }
                            }
                            if (!CollectionUtils.isEmpty(patent.getRightHolder())) {
                                List<PatentPerson> rightHolder = patent.getRightHolder();
                                for (PatentPerson patentPerson : rightHolder) {
                                    PatentMergePerson merge = new PatentMergePerson();
                                    merge.setName(patentPerson.getName());
                                    merge.setType(patentPerson.getType());
                                    merge.setOrder(patentPerson.getOrder());
                                    merge.setProjectId(String.valueOf(projectId));
                                    rightPersonList.add(merge);
                                }
                            }
                        } else {
                            if (!CollectionUtils.isEmpty(patent.getInventor())) {
                                List<PatentPerson> inventor = patent.getInventor();
                                for (PatentPerson patentPerson : inventor) {
                                    PatentMergePerson merge = new PatentMergePerson();
                                    merge.setName(patentPerson.getName());
                                    merge.setType(patentPerson.getType());
                                    merge.setOrder(patentPerson.getOrder());
                                    merge.setProjectId(String.valueOf(projectId));
                                    inventorPersonList.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()) {
                                    //添加子文档
                                    Patent newPatent = new Patent();
                                    PatentJoin patentJoin = new PatentJoin();
                                    patentJoin.setParent(id);
                                    patentJoin.setName("merge_applicat");
                                    newPatent.setPatentJoin(patentJoin);
                                    newPatent.setMergeApplicant(appPersonList);
                                    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()) {
                                    //添加子文档
                                    Patent newPatent = new Patent();
                                    PatentJoin patentJoin = new PatentJoin();
                                    patentJoin.setParent(id);
                                    patentJoin.setName("merge_right_holder");
                                    newPatent.setPatentJoin(patentJoin);
                                    newPatent.setMergeInventor(rightPersonList);
                                    String child = this.addChild(newPatent, id);
                                    if (StringUtils.isEmpty(child)) {
                                        throw new XiaoShiException("删除失败");
                                    } else {
                                        //删除原子文档
                                        this.delete(Arrays.asList(rightId));
                                    }
                                }
                            }
                        } else {
                            //发明人
                            Map<String, List<PatentMergePerson>> inventorMap = this.getChildMergePerson(id, projectId, "merge_inventor");
                            if (!CollectionUtils.isEmpty(inventorMap)) {
                                for (String inventorId : inventorMap.keySet()) {
                                    //添加子文档
                                    Patent newPatent = new Patent();
                                    PatentJoin patentJoin = new PatentJoin();
                                    patentJoin.setParent(id);
                                    patentJoin.setName("merge_inventor");
                                    newPatent.setPatentJoin(patentJoin);
                                    newPatent.setMergeInventor(inventorPersonList);
                                    String child = this.addChild(newPatent, id);
                                    if (StringUtils.isEmpty(child)) {
                                        throw new XiaoShiException("删除失败");
                                    } else {
                                        //删除原子文档
                                        this.delete(Arrays.asList(inventorId));
                                    }
                                }
                            }
                        }
                    }
                    mergePersonMapper.deleteById(person.getId());
                }
            }
        }

        if (!CollectionUtils.isEmpty(mergeName)) {
            nameList.addAll(mergeName);
        }

        MergePersonVO personVO = new MergePersonVO();
        personVO.setProjectId(projectId);
        personVO.setType(type);
        personVO.setName(vo.getName());
        personVO.setAbbreviation(vo.getAbbreviation());
        personVO.setCountry(vo.getCountry());
        personVO.setProvince(vo.getProvince());
        personVO.setAddress(vo.getAddress());
        personVO.setRemark(vo.getRemark());
        personVO.setMergedName(nameList);
        Integer id = this.mergePerson(personVO);
        if (id < 0) {
            throw new XiaoShiException("再合并失败");
        }
        return id;
    }

    /**
     * 专利列表上编辑发明人/权利人/申请人合并
     *
     * @param vo
     * @return
     * @throws Exception
     */
    @Transactional(propagation = Propagation.REQUIRED, rollbackFor = Throwable.class)
    public Integer updateMergePerson(MergePersonVO vo) throws Exception {
        //获取登陆人信息 用于设置创建人
        PersonnelVO personnelVO = new PersonnelVO();
        Integer type = vo.getType();
        try {
            personnelVO = cacheUtils.getLoginUser(loginUtils.getId());
        } catch (Exception e) {
            throw new XiaoShiException("未登录");
        }
        //判断是否名称重复
        LambdaQueryWrapper<MergePerson> wrapper = new LambdaQueryWrapper<MergePerson>()
                .eq(MergePerson::getProjectId, vo.getProjectId())
                .eq(MergePerson::getName, vo.getName())
                .ne(BaseEntity::getId, vo.getId());
        List<MergePerson> list = mergePersonMapper.selectList(wrapper);
        if (list.size() > 0) {
            throw new XiaoShiException("合并名称不可重复");
        }
        //获取老专利
        MergePerson person = this.getById(vo.getId());
        String name = person.getName();
        Integer projectId = person.getProjectId();

        if (ObjectUtil.isNotEmpty(person)) {
            BeanUtils.copyProperties(vo, person);
            person.setCreateId(personnelVO.getId());
            person.setCreateTime(new Date());
            person.updateById();

            if (!name.equals(vo.getName())) {
                SearchRequest.Builder builder = new SearchRequest.Builder();
                //设置查询索引
                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 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 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);
                SearchResponse<Patent> response = client.search(builder.build(), Patent.class);
                List<Hit<Patent>> hits = response.hits().hits();
                Map<String, Patent> map = new HashMap<>();
                for (Hit<Patent> hit : hits) {
                    String id = hit.id();
                    map.put(id, hit.source());
                }

                if (!CollectionUtils.isEmpty(map)) {
                    for (String id : map.keySet()) {
                        if (type == 0) {
                            //申请人
                            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());
                                }
                            }

                            //权利人
                            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());
                                }
                            }
                        } 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.edit(inventorId, type, name, vo.getName());
                                }
                            }
                        }
                    }
                } else {
                    throw new XiaoShiException("编辑失败");
                }
            }
        } else {
            person = new MergePerson();
        }
        return person.getId();
    }

    /**
     * 发明人/权利人/申请人合并列表查询
     *
     * @param vo
     * @return
     */
    public Records selectMergePersonList(MergePersonQueryVO vo) {
        List<MergePersonQueryDTO> list = new ArrayList<>();
        IPage<MergePerson> page = new Page<>(vo.getPageNum(), vo.getPageSize());
        LambdaQueryWrapper<MergePerson> wrapper = new LambdaQueryWrapper<MergePerson>()
                .eq(MergePerson::getProjectId, vo.getProjectId())
                .eq(MergePerson::getType, vo.getType())
                .eq(StringUtils.isNotEmpty(vo.getCountry()), MergePerson::getCountry, vo.getCountry())
                .like(StringUtils.isNotEmpty(vo.getName()), MergePerson::getName, vo.getName());
        IPage<MergePerson> record = mergePersonMapper.selectPage(page, wrapper);
        for (MergePerson person : record.getRecords()) {
            MergePersonQueryDTO dto = new MergePersonQueryDTO();
            dto.setId(person.getId());
            dto.setProjectId(person.getProjectId());
            dto.setType(person.getType());
            dto.setName(person.getName());
            dto.setAddress(person.getAddress());
            dto.setCountry(person.getCountry());
            dto.setProvince(person.getProvince());
            dto.setRemark(person.getRemark());
            dto.setAbbreviation(person.getAbbreviation());
            dto.setCreateTime(person.getCreateTime());
            List<String> names = JSONArray.parseArray(person.getMergedName(), String.class);
            dto.setMergedName(names);
            list.add(dto);
        }
        Records records = new Records();
        records.setCurrent(record.getCurrent());
        records.setSize(record.getSize());
        records.setData(list);
        records.setTotal(record.getTotal());
        return records;
    }

    /**
     * 合并人员详情
     *
     * @param vo
     * @return
     */
    public MergePersonQueryDTO selectMergePersonDetail(MergePersonIdVO vo) {
        MergePersonQueryDTO dto = new MergePersonQueryDTO();
        MergePerson person = mergePersonMapper.selectById(vo.getId());
        if (ObjectUtil.isNotEmpty(person)) {
            BeanUtils.copyProperties(person, dto);
            List<String> names = JSONArray.parseArray(person.getMergedName(), String.class);
            dto.setMergedName(names);
        }
        return dto;
    }

    /**
     * 获取所有发明人/权利人/申请人
     *
     * @param vo
     * @return
     * @throws Exception
     */
    public Records getMergePerson(GetAllPersonVO vo) throws Exception {
        Integer projectId = vo.getProjectId();
        Long pageNum = vo.getPageNum();
        Long pageSize = vo.getPageSize();
        Integer type = vo.getType();
        String condition = vo.getSearchQuery();

        List<String> conditionList = new ArrayList<>();
        long total = 0l;
        if (StringUtils.isNotEmpty(condition)) {
            String s = condition.substring(condition.indexOf("=") + 1);
            if (s.contains("or")) {
                String[] split = s.split("or");
                conditionList.addAll(Arrays.asList(split));
            } else {
                conditionList.add(s);
            }
        }

        List<GetEsAllPersonDTO> personDTOS = new ArrayList<>();
        SearchRequest.Builder builder = new SearchRequest.Builder();
        //设置查询索引
        builder.index("patent");
//        Query mustQ = QueryBuilders.hasChild(i -> i.type("project").query(j -> j.term(n -> n.field("project_id").value(projectId))));
        if (!CollectionUtils.isEmpty(conditionList)) {
            for (String name : conditionList) {
                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 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 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 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());
                }
//                builder.trackTotalHits(i -> i.enabled(true));
                SearchResponse<Patent> response = client.search(builder.build(), Patent.class);
                total = response.hits().total().value();
                List<Hit<Patent>> hits = response.hits().hits();
                Map<String, Patent> map = new HashMap<>();
                for (Hit<Patent> hit : hits) {
                    String id = hit.id();
                    map.put(id, hit.source());
                }

                if (!CollectionUtils.isEmpty(map)) {
                    for (String id : map.keySet()) {
                        GetEsAllPersonDTO personDTO = new GetEsAllPersonDTO();
                        if (type == 0) {
                            //申请人
                            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());
                                    personDTO.setMergeApplicant(collect);
                                }
                            }
                            //权利人
                            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());
                                    personDTO.setMergeRightHolder(collect);
                                }
                            }
                        } else {
                            //发明人
                            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());
                                    personDTO.setMergeInventor(collect);
                                }
                            }
                        }
                        personDTOS.add(personDTO);
                    }
                }
            }
        } else {
            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));
                Query childQ1 = QueryBuilders.hasChild(i -> i.type("merge_applicat").query(query1));
                queries.add(childQ1);

                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));
                Query childQ2 = QueryBuilders.hasChild(i -> i.type("merge_right_holder").query(query2));
                queries.add(childQ2);
            } 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));
                Query childQ = QueryBuilders.hasChild(i -> i.type("merge_inventor").query(query));
                queries.add(childQ);
            }
            Query bool = QueryBuilders.bool(i -> i.should(queries));
//            builder.size(99);
            builder.query(bool);
            //分页
            if (pageNum > 0 && pageSize > 0) {
                builder.from((pageNum.intValue() - 1) * pageSize.intValue()).size(pageSize.intValue());
            }

            builder.trackTotalHits(i -> i.enabled(true));
            SearchResponse<Patent> response = client.search(builder.build(), Patent.class);
            List<Hit<Patent>> hits = response.hits().hits();
            total = response.hits().total().value();
            Map<String, Patent> map = new HashMap<>();
            for (Hit<Patent> hit : hits) {
                String id = hit.id();
                map.put(id, hit.source());
            }

            if (!CollectionUtils.isEmpty(map)) {
                for (String id : map.keySet()) {
                    GetEsAllPersonDTO personDTO = new GetEsAllPersonDTO();
                    if (type == 0) {
                        //申请人
                        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());
                                personDTO.setMergeApplicant(collect);
                            }
                        }
                        //权利人
                        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());
                                personDTO.setMergeRightHolder(collect);
                            }
                        }
                    } else {
                        //发明人
                        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());
                                personDTO.setMergeInventor(collect);
                            }
                        }
                    }
                    personDTOS.add(personDTO);
                }
            }
        }


        //es申请人/权利人
        List<String> mergeList = new ArrayList<>();
        if (!CollectionUtils.isEmpty(personDTOS)) {
            if (type == 0) {
                for (GetEsAllPersonDTO personDTO : personDTOS) {
                    List<String> appList = new ArrayList<>();
                    if (!CollectionUtils.isEmpty(personDTO.getMergeApplicant())) {
                        appList = personDTO.getMergeApplicant();
                        mergeList.addAll(appList);
                    }
                    List<String> rightList = new ArrayList<>();
                    if (!CollectionUtils.isEmpty(personDTO.getMergeRightHolder())) {
                        rightList = personDTO.getMergeRightHolder();
                        mergeList.addAll(rightList);
                    }
                }
            } else {
                for (GetEsAllPersonDTO personDTO : personDTOS) {
                    List<String> inventorList = new ArrayList<>();
                    if (!CollectionUtils.isEmpty(personDTO.getMergeInventor())) {
                        inventorList = personDTO.getMergeInventor();
                        mergeList.addAll(inventorList);
                    }

                }
            }
        }

        List<GetAllPersonDTO> personDTOList = new ArrayList<>();
        List<GetAllPersonDTO> mergePersonList = new ArrayList<>();
        List<GetAllPersonDTO> personList = new ArrayList<>();

        List<String> nameList = mergeList.stream().distinct().collect(Collectors.toList());
        List<String> mergedList = new ArrayList<>();
        for (String key : nameList) {
            MergePerson person = mergePersonMapper.selectOne(new LambdaQueryWrapper<MergePerson>()
                    .eq(MergePerson::getName, key)
                    .eq(MergePerson::getProjectId, projectId));
            if (ObjectUtils.isNotEmpty(person)) {
                GetAllPersonDTO dto = new GetAllPersonDTO();
                dto.setName(person.getName());
                dto.setMergeId(person.getId());
                dto.setType(person.getType());
                dto.setRemark(person.getRemark());
                dto.setAbbreviation(person.getAbbreviation());
                dto.setCountry(person.getCountry());
                dto.setProvince(person.getProvince());
                dto.setAddress(person.getAddress());
                String mergedName = person.getMergedName();
                List<String> getNames = JSONArray.parseArray(mergedName, String.class);
                mergedList.addAll(getNames);
                mergePersonList.add(dto);
            } else {
                GetAllPersonDTO dto = new GetAllPersonDTO();
                dto.setName(key);
                personList.add(dto);
            }
        }

        if (!CollectionUtils.isEmpty(mergePersonList)) {
            List<GetAllPersonDTO> collect = mergePersonList.stream().sorted(Comparator.comparing(GetAllPersonDTO::getName)).collect(Collectors.toList());
            personDTOList.addAll(collect);
        }

        if (!CollectionUtils.isEmpty(personList)) {
            if (!CollectionUtils.isEmpty(mergedList)) {
                for (String s : mergedList) {
                    personList.removeIf(i -> i.getName().equals(s));
                }
            }

            List<GetAllPersonDTO> collect = personList.stream().filter(i -> !StringUtils.isEmpty(i.getName())).collect(Collectors.toList());
            List<GetAllPersonDTO> list = collect.stream().sorted(Comparator.comparing(GetAllPersonDTO::getName)).collect(Collectors.toList());

            personDTOList.addAll(list);
        }

//        List<GetAllPersonDTO> collect = personDTOList.stream().skip((pageNum - 1) * pageSize).limit(pageSize).collect(Collectors.toList());

        Records records = new Records();
        records.setCurrent(pageNum);
        records.setSize(pageSize);
        records.setData(personDTOList);
        records.setTotal(total);
        return records;
    }

    /**
     * 发明人/权利人/申请人合并后的名称移除
     *
     * @param vo
     * @return
     * @throws Exception
     */
    @Transactional(propagation = Propagation.REQUIRED, rollbackFor = Throwable.class)
    public Integer delMergedName(MergedNameVO vo) throws Exception {
        Integer type = vo.getType();
        //要移除的名字
        String delName = vo.getDelName();
        //合并后的名称
        String name = vo.getName();
        Integer projectId = vo.getProjectId();
        MergePerson mergePerson = mergePersonMapper.selectOne(new LambdaQueryWrapper<MergePerson>()
                .eq(MergePerson::getName, name)
                .eq(MergePerson::getProjectId, projectId));
        if (ObjectUtil.isNotEmpty(mergePerson)) {
            Integer personId = mergePerson.getId();
            String mergedName = mergePerson.getMergedName();
            List<String> list = JSONArray.parseArray(mergedName, String.class);
            list.remove(delName);
            MergePerson person = mergePersonMapper.selectById(personId);
            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");
            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 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 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);
            SearchResponse<Patent> response = client.search(builder.build(), Patent.class);
            List<Hit<Patent>> hits = response.hits().hits();
            Map<String, Patent> map = new HashMap<>();
            for (Hit<Patent> hit : hits) {
                String id = hit.id();
                map.put(id, hit.source());
            }

            if (!CollectionUtils.isEmpty(map)) {
                for (String id : map.keySet()) {
                    Patent patent = map.get(id);
                    List<PatentMergePerson> mergePersonList = new ArrayList<>();
                    if (type == 0) {
                        if (!CollectionUtils.isEmpty(patent.getApplicant())) {
                            List<PatentPerson> applicant = patent.getApplicant();
                            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) && !CollectionUtils.isEmpty(patent.getRightHolder())) {
                            List<PatentPerson> rightHolder = patent.getRightHolder();
                            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 {
                        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);
                                    }
                                }
                            }
                        }
                    }

                    if (type == 0) {
                        //申请人
                        Map<String, List<PatentMergePerson>> appMap = this.getChildMergePerson(id, projectId, "merge_applicant");
                        if (!CollectionUtils.isEmpty(appMap)) {
                            for (String appId : appMap.keySet()) {
//                                if (CollectionUtils.isEmpty(nameDatas)) {
//                                    this.delSingleMerge(appId, type, name);
//                                }

                                List<PatentMergePerson> appMergeList = new ArrayList<>(mergePersonList);
                                List<PatentMergePerson> appList = appMap.get(appId);
                                appMergeList.addAll(appList);
                                if (CollectionUtils.isEmpty(nameDatas)) {
                                    if (!CollectionUtils.isEmpty(appMergeList)) {
                                        appMergeList.removeIf(app -> app.getName().equals(name));
                                    }
                                }
                                //添加子文档
                                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()) {
//                                if (CollectionUtils.isEmpty(nameDatas)) {
//                                    this.delSingleMerge(rightId, type, name);
//                                }

                                ArrayList<PatentMergePerson> rightMergeList = new ArrayList<>(mergePersonList);
                                List<PatentMergePerson> rightList = rightMap.get(rightId);
                                rightMergeList.addAll(rightList);
                                if (CollectionUtils.isEmpty(nameDatas)) {
                                    if (!CollectionUtils.isEmpty(rightMergeList)) {
                                        rightMergeList.removeIf(right -> right.getName().equals(name));
                                    }
                                }
                                //添加子文档
                                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()) {
//                                if (CollectionUtils.isEmpty(nameDatas)) {
//                                    this.delSingleMerge(inventorId, type, name);
//                                }

                                ArrayList<PatentMergePerson> inventorMergeList = new ArrayList<>(mergePersonList);
                                List<PatentMergePerson> inventorList = inventorMap.get(inventorId);
                                inventorMergeList.addAll(inventorList);
                                if (CollectionUtils.isEmpty(nameDatas)) {
                                    if (!CollectionUtils.isEmpty(inventorMergeList)) {
                                        inventorMergeList.removeIf(inventor -> inventor.getName().equals(name));
                                    }
                                }
                                //添加子文档
                                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("移除失败");
            }
        }
        return mergePerson.getId();
    }

    /**
     * 发明人/权利人/申请人合并记录删除
     *
     * @param vo
     * @return
     * @throws Exception
     */
    @Transactional(propagation = Propagation.REQUIRED, rollbackFor = Throwable.class)
    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>()
                    .eq(BaseEntity::getId, vo.getId());
            this.remove(wrapper);

            List<String> list = JSONArray.parseArray(mergedName, String.class);
            if (!CollectionUtils.isEmpty(list)) {
                Map<String, Patent> map = this.getDelPatent(type, projectId, name);

                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(patent.getRightHolder()) && list.size() != mergePersonList.size()) {
                                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 {
                            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);
                                    }
                                }
                            }
                        }

                        if (type == 0) {
                            //申请人
                            Map<String, List<PatentMergePerson>> appMap = this.getChildMergePerson(id, projectId, "merge_applicant");
                            if (!CollectionUtils.isEmpty(appMap)) {
                                for (String appId : appMap.keySet()) {

                                    List<PatentMergePerson> appMergeList = new ArrayList<>(mergePersonList);
                                    List<PatentMergePerson> appList = appMap.get(appId);
                                    appMergeList.addAll(appList);
                                    if (!CollectionUtils.isEmpty(appMergeList)) {
                                        appMergeList.removeIf(app -> app.getName().equals(name));
                                    }
                                    //添加子文档
                                    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()) {

                                    ArrayList<PatentMergePerson> rightMergeList = new ArrayList<>(mergePersonList);
                                    List<PatentMergePerson> rightList = rightMap.get(rightId);
                                    rightMergeList.addAll(rightList);
                                    if (!CollectionUtils.isEmpty(rightMergeList)) {
                                        rightMergeList.removeIf(right -> right.getName().equals(name));
                                    }
                                    //添加子文档
                                    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()) {

                                    ArrayList<PatentMergePerson> inventorMergeList = new ArrayList<>(mergePersonList);
                                    List<PatentMergePerson> inventorList = inventorMap.get(inventorId);
                                    inventorMergeList.addAll(inventorList);
                                    if (!CollectionUtils.isEmpty(inventorMergeList)) {
                                        inventorMergeList.removeIf(inventor -> inventor.getName().equals(name));
                                    }
                                    //添加子文档
                                    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("删除失败");
                }
            }
        }
        return vo.getId();
    }

    public Map<String, Patent> getDelPatent(Integer type, Integer projectId, String name) throws IOException {
        SearchRequest.Builder builder = new SearchRequest.Builder();
        //设置查询索引
        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 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 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);
        SearchResponse<Patent> response = client.search(builder.build(), Patent.class);
        List<Hit<Patent>> hits = response.hits().hits();
        Map<String, Patent> map = new HashMap<>();
        for (Hit<Patent> hit : hits) {
            String id = hit.id();
            map.put(id, hit.source());
        }
        return map;
    }

    /**
     * 获取所有国家列表查询
     *
     * @return
     */
    public List<GetAllCountryDTO> getAllCountry() {
        List<GetAllCountryDTO> list = new ArrayList<>();
        List<SystemDict> countries = systemDictMapper.selectList(new LambdaQueryWrapper<SystemDict>()
                .eq(SystemDict::getType, "COUNTRIES"));
        if (!CollectionUtils.isEmpty(countries)) {
            countries.forEach(county -> {
                GetAllCountryDTO dto = new GetAllCountryDTO();
                dto.setLabel(county.getLabel());
                dto.setValue(county.getValue());
                dto.setType(county.getType());
                list.add(dto);
            });
        }
        return list;
    }

    /**
     * 获取国内省份列表查询
     *
     * @return
     */
    public List<GetAllCountryDTO> getAllProvince() {
        List<GetAllCountryDTO> list = new ArrayList<>();
        List<SystemDict> countries = systemDictMapper.selectList(new LambdaQueryWrapper<SystemDict>()
                .eq(SystemDict::getType, "PROVINCE"));
        if (!CollectionUtils.isEmpty(countries)) {
            countries.forEach(county -> {
                GetAllCountryDTO dto = new GetAllCountryDTO();
                dto.setLabel(county.getLabel());
                dto.setValue(county.getValue());
                dto.setType(county.getType());
                list.add(dto);
            });
        }
        return list;
    }


    /**
     * @param patent
     * @throws Exception
     */
    public String addChild(Patent patent, String id) throws Exception {
        IndexResponse indexResponse = client.index(i -> i
                .index("patent")
                .routing(id)
                //传入user对象
                .document(patent)
        );
        return indexResponse.id();
    }

    //更新patent
    public Integer updateChild(Patent patent, String id, String routing) {
        UpdateRequest<Patent, Patent> req;
        req = UpdateRequest.of(
                b -> b.index("patent")
                        .id(id)
                        .routing(id)
                        .doc(patent)
        );
        try {
            client.update(req, Patent.class);
            return 1;
        } catch (IOException e) {
            return -1;
        }
    }

    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 id
     * @return
     */
    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); }";
        } 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;
        }
    }


    public Integer add(String id, Integer type, List<PatentMergePerson> mergePersonList) {
        Integer flag = null;
        for (PatentMergePerson mergePerson : mergePersonList) {
            Map<String, JsonData> map = new HashMap<>();
            map.put("name", JsonData.of(mergePerson.getName()));
            map.put("project_id", JsonData.of(mergePerson.getProjectId()));
            map.put("type", JsonData.of(mergePerson.getType()));
            map.put("order", JsonData.of(mergePerson.getOrder()));
            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(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);
                flag += 1;
            } catch (IOException e) {
                flag += -1;
            }
        }
        return flag;
    }

    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;
        }
    }
}