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.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.Patent;
import cn.cslg.pas.domain.es.PatentMergePerson;
import cn.cslg.pas.domain.es.PatentPerson;
import cn.cslg.pas.domain.es.PersonAddress;
import cn.cslg.pas.exception.UnLoginException;
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.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.Query;
import co.elastic.clients.elasticsearch._types.query_dsl.QueryBuilders;
import co.elastic.clients.elasticsearch.core.SearchRequest;
import co.elastic.clients.elasticsearch.core.SearchResponse;
import co.elastic.clients.elasticsearch.core.search.Hit;
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.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;

    @Transactional(propagation = Propagation.REQUIRED, rollbackFor = Throwable.class)
    public Integer mergePerson(MergePersonVO vo) throws Exception {
        Integer type = vo.getType();
        List<String> mergedNames = vo.getMergedName();
        //获取登陆人信息 用于设置创建人
        PersonnelVO personnelVO = new PersonnelVO();
        try {
            personnelVO = cacheUtils.getLoginUser(loginUtils.getId());
        } catch (Exception e) {
            throw new UnLoginException("未登录");
        }
        //判断是否名称重复
        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() > 1) {
            throw new Exception("合并名称不可重复");
        }

        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 q1 = QueryBuilders.term(i -> i.field("applicant.name.key").value(mergedName));
                Query query1 = QueryBuilders.nested(i -> i.path("applicant").query(q1));
                Query q2 = QueryBuilders.term(i -> i.field("right_holder.name.key").value(mergedName));
                Query query2 = QueryBuilders.nested(i -> i.path("right_holder").query(q2));
                queries.add(query1);
                queries.add(query2);
            }
        } else {
            for (String mergedName : mergedNames) {
                Query q = QueryBuilders.term(i -> i.field("inventor.name.key").value(mergedName));
                Query query = QueryBuilders.nested(i -> i.path("inventor").query(q));
                queries.add(query);
            }
        }
        Query 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()) {
                Patent patent = map.get(id);
                if (type == 0) {
                    //申请人
                    List<PatentMergePerson> mergeApplicants = new ArrayList<>();
                    if (!CollectionUtils.isEmpty(patent.getMergeApplicant())) {
                        mergeApplicants = patent.getMergeApplicant();
                    }
                    mergeApplicants.addAll(mergePersonList);
                    //权利人
                    List<PatentMergePerson> mergeRightHolder = new ArrayList<>();
                    if (!CollectionUtils.isEmpty(patent.getMergeRightHolder())) {
                        mergeRightHolder = patent.getMergeRightHolder();
                    }
                    mergeRightHolder.addAll(mergePersonList);
                    patent.setMergeApplicant(mergeApplicants);
                    patent.setMergeRightHolder(mergeRightHolder);
                } else if (type == 2) {
                    List<PatentMergePerson> mergeInventor = new ArrayList<>();
                    if (!CollectionUtils.isEmpty(patent.getMergeInventor())) {
                        mergeInventor = patent.getMergeInventor();
                    }
                    mergeInventor.addAll(mergePersonList);
                    patent.setMergeInventor(mergeInventor);
                }
                esService.updateMergePerson(patent, id);
            }
        }
        return person.getId();
    }

    @Transactional(propagation = Propagation.REQUIRED, rollbackFor = Throwable.class)
    public Integer mergePersonAgain(MergePersonAgainVO vo) throws Exception {
        List<String> mergedNames = vo.getNeedMergedName();
        List<String> mergeName = vo.getMergeName();
        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);

                MergePersonIdVO personIdVO = new MergePersonIdVO();
                personIdVO.setId(person.getId());
                personIdVO.setType(person.getType());
                this.delMergePerson(personIdVO);
            }
        }

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

        MergePersonVO personVO = new MergePersonVO();
        personVO.setProjectId(vo.getProjectId());
        personVO.setType(vo.getType());
        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);
        return this.mergePerson(personVO);
    }

    @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 UnLoginException("未登录");
        }
        //判断是否名称重复
        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() > 1) {
            throw new Exception("合并名称不可重复");
        }
        //获取老专利
        MergePerson person = this.getById(vo.getId());
        String mergedName = person.getMergedName();
        String name = person.getName();

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

            if (!name.equals(vo.getName())) {
                List<String> mergedNames = JSONArray.parseArray(mergedName, String.class);
                SearchRequest.Builder builder = new SearchRequest.Builder();
                //设置查询索引
                builder.index("patent");

                List<Query> queries = new ArrayList<>();
                if (type == 0) {
                    for (String merged : mergedNames) {
                        Query q1 = QueryBuilders.term(i -> i.field("applicant.name.key").value(merged));
                        Query query1 = QueryBuilders.nested(i -> i.path("applicant").query(q1));
                        Query q2 = QueryBuilders.term(i -> i.field("right_holder.name.key").value(merged));
                        Query query2 = QueryBuilders.nested(i -> i.path("right_holder").query(q2));
                        queries.add(query1);
                        queries.add(query2);
                    }
                } else {
                    for (String merged : mergedNames) {
                        Query q = QueryBuilders.term(i -> i.field("inventor.name.key").value(merged));
                        Query query = QueryBuilders.nested(i -> i.path("inventor").query(q));
                        queries.add(query);
                    }
                }
                Query 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);
                        if (type == 0) {
                            //申请人
                            List<PatentMergePerson> mergeApplicants = new ArrayList<>();
                            if (!CollectionUtils.isEmpty(patent.getMergeApplicant())) {
                                mergeApplicants = patent.getMergeApplicant();

                                for (PatentMergePerson mergeApplicant : mergeApplicants) {
                                    if (mergeApplicant.getName().equals(name)) {
                                        mergeApplicant.setName(vo.getName());
                                    }
                                }

                                patent.setMergeApplicant(mergeApplicants);
                            }

                            //权利人
                            List<PatentMergePerson> mergeRightHolders = new ArrayList<>();
                            if (!CollectionUtils.isEmpty(patent.getMergeRightHolder())) {
                                mergeRightHolders = patent.getMergeRightHolder();
                                for (PatentMergePerson mergeRightHolder : mergeRightHolders) {
                                    if (mergeRightHolder.getName().equals(name)) {
                                        mergeRightHolder.setName(vo.getName());
                                    }
                                }

                                patent.setMergeRightHolder(mergeRightHolders);
                            }

                        } else if (type == 2) {
                            List<PatentMergePerson> mergeInventors = new ArrayList<>();
                            if (!CollectionUtils.isEmpty(patent.getMergeInventor())) {
                                mergeInventors = patent.getMergeInventor();

                                for (PatentMergePerson mergeInventor : mergeInventors) {
                                    if (mergeInventor.getName().equals(name)) {
                                        mergeInventor.setName(vo.getName());
                                    }
                                }

                                patent.setMergeInventor(mergeInventors);
                            }
                        }

                        esService.updateMergePerson(patent, id);
                    }
                }
            }
        } else {
            person = new MergePerson();
        }
        return person.getId();
    }

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

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

    public Records getMergePerson(GetAllPersonVO vo) throws Exception {
        Integer projectId = vo.getProjectId();
        Integer taskId = vo.getTaskId();
        Long pageNum = vo.getPageNum();
        Long pageSize = vo.getPageSize();
        Integer type = vo.getType();
        String searchCondition = "";
        if (type == 0 && StringUtils.isNotEmpty(vo.getName())) {
            searchCondition = searchCondition + "PA = " + vo.getName() + " " + "OR" + " " + "PE =" + vo.getName();
        } else if (type == 2 && StringUtils.isNotEmpty(vo.getName())) {
            searchCondition = searchCondition + "IN = " + vo.getName();
        }
        if (taskId != null) {
            if (searchCondition != null && !"".equals(searchCondition.trim())) {
                searchCondition = "taskId = " + taskId + " AND " + searchCondition;
            } else {
                searchCondition = "taskId = " + taskId;
            }
        } else {
            if (projectId != null) {
                if (searchCondition != null && !"".equals(searchCondition.trim())) {
                    searchCondition = "projectId = " + projectId + " AND " + searchCondition;
                } else {
                    searchCondition = "projectId = " + projectId;
                }
            }
        }
        SearchRequest.Builder builder = new SearchRequest.Builder();
        //设置查询索引
        builder.index("patent");
        //1. 解析检索条件
        treeNode tree = expressManager.getInstance().Parse(searchCondition, false);
        //格式化检索式
        //3. 从es中检索数据
        Query q = formatQueryService.EsQueryToQuery((operateNode) tree, "patent");
        builder.query(q);
        //分页
//        if (pageNum > 0 && pageSize > 0) {
//            builder.from((pageNum - 1) * pageSize).size(pageSize);
//        }
        SearchResponse<Patent> response = client.search(builder.build(), Patent.class);
        List<Hit<Patent>> hits = response.hits().hits();
        List<GetEsAllPersonDTO> personDTOS = new ArrayList<>();
        for (Hit<Patent> hit : hits) {
            Patent esMess = hit.source();
            PersonAddress applicantAddr = null;
            GetEsAllPersonDTO personDTO = new GetEsAllPersonDTO();
            personDTO.setApplicantAddr(esMess.getApplicantAddr());
            personDTO.setRightHolderAddr(esMess.getRightHolderAddr());
            personDTO.setApplicant(esPatentService.loadName(esMess.getApplicant()));
            personDTO.setRightHolder(esPatentService.loadName(esMess.getRightHolder()));
            personDTO.setInventor(esPatentService.loadName(esMess.getInventor()));
            personDTOS.add(personDTO);
        }

        //es申请人/权利人
        List<GetAllPersonDTO> personDTOList = new ArrayList<>();
        //申请人
        List<GetAllPersonDTO> applicantDTOS = new ArrayList<>();
        if (!CollectionUtils.isEmpty(personDTOS)) {
            for (GetEsAllPersonDTO personDTO : personDTOS) {
                PersonAddress applicantAddr = personDTO.getApplicantAddr();
                if (ObjectUtil.isNotEmpty(applicantAddr)) {
                    List<String> applicant = personDTO.getApplicant();
                    for (String s : applicant) {
                        GetAllPersonDTO dto = new GetAllPersonDTO();
                        dto.setName(s);
                        dto.setType(0);
                        if (StringUtils.isNotEmpty(applicantAddr.getCountry())) {
                            dto.setCountry(applicantAddr.getCountry());
                        }
                        if (StringUtils.isNotEmpty(applicantAddr.getAddress())) {
                            dto.setAddress(applicantAddr.getAddress());
                        }
                        applicantDTOS.add(dto);
                    }
                } else {
                    List<String> applicant = personDTO.getApplicant();
                    for (String s : applicant) {
                        GetAllPersonDTO dto = new GetAllPersonDTO();
                        dto.setName(s);
                        dto.setType(0);
                        applicantDTOS.add(dto);
                    }
                }
            }
        }

        //权利人
        List<GetAllPersonDTO> rightDTOS = new ArrayList<>();
        if (!CollectionUtils.isEmpty(personDTOS)) {
            for (GetEsAllPersonDTO personDTO : personDTOS) {
                PersonAddress rightHolderAddr = personDTO.getRightHolderAddr();
                if (ObjectUtil.isNotEmpty(rightHolderAddr)) {
                    List<String> rightHolder = personDTO.getRightHolder();
                    for (String s : rightHolder) {
                        GetAllPersonDTO dto = new GetAllPersonDTO();
                        dto.setName(s);
                        dto.setType(0);
                        if (StringUtils.isNotEmpty(rightHolderAddr.getCountry())) {
                            dto.setCountry(rightHolderAddr.getCountry());
                        }
                        if (StringUtils.isNotEmpty(rightHolderAddr.getAddress())) {
                            dto.setAddress(rightHolderAddr.getAddress());
                        }
                        rightDTOS.add(dto);
                    }
                } else {
                    List<String> rightHolder = personDTO.getRightHolder();
                    for (String s : rightHolder) {
                        GetAllPersonDTO dto = new GetAllPersonDTO();
                        dto.setName(s);
                        dto.setType(0);
                        rightDTOS.add(dto);
                    }
                }
            }
        }

        //申请人和权利人相同的去除
        if (!CollectionUtils.isEmpty(applicantDTOS) && !CollectionUtils.isEmpty(rightDTOS)) {
            for (GetAllPersonDTO applicantDTO : applicantDTOS) {
                rightDTOS.removeIf(rightDTO -> applicantDTO.getName().equals(rightDTO.getName()));
            }
        }
        //装载在同一个集合
        personDTOList.addAll(applicantDTOS);
        personDTOList.addAll(rightDTOS);

        //发明人
        List<GetAllPersonDTO> inventorDTOS = new ArrayList<>();
        if (!CollectionUtils.isEmpty(personDTOS)) {
            for (GetEsAllPersonDTO personDTO : personDTOS) {
                List<String> inventor = personDTO.getInventor();
                for (String s : inventor) {
                    GetAllPersonDTO dto = new GetAllPersonDTO();
                    dto.setName(s);
                    dto.setType(2);
                    inventorDTOS.add(dto);
                }
            }
        }

        //查询合并信息表中数据
//        IPage<MergePerson> page = new Page<>(vo.getPageNum(), vo.getPageSize());
        LambdaQueryWrapper<MergePerson> wrapper = new LambdaQueryWrapper<MergePerson>()
                .eq(MergePerson::getProjectId, vo.getProjectId())
                .eq(StringUtils.isNotEmpty(vo.getName()), MergePerson::getName, vo.getName())
                .orderByDesc(MergePerson::getCreateTime);
//        IPage<MergePerson> record = mergePersonMapper.selectPage(page, wrapper);
        List<MergePerson> mergePersonList = mergePersonMapper.selectList(wrapper);
        //合并
        List<GetAllPersonDTO> mergeList = new ArrayList<>();
        //申请人/权利人
        List<GetAllPersonDTO> applicantMergeList = new ArrayList<>();
        //发明人
        List<GetAllPersonDTO> inventorMergeList = new ArrayList<>();
//        List<MergePerson> mergePersonList = record.getRecords();
        if (!CollectionUtils.isEmpty(mergePersonList)) {
            for (MergePerson person : mergePersonList) {
                Integer personType = person.getType();
                GetAllPersonDTO merge = new GetAllPersonDTO();
                merge.setName(person.getName());
                merge.setCountry(person.getCountry());
                merge.setAddress(person.getAddress());
                merge.setRemark(person.getRemark());
                merge.setType(personType);
                merge.setMergeId(person.getId());
                mergeList.add(merge);

                if (personType == 0) {
                    List<String> applicantMerges = JSONArray.parseArray(person.getMergedName(), String.class);
                    if (!CollectionUtils.isEmpty(applicantMerges)) {
                        for (String applicantMerge : applicantMerges) {
                            GetAllPersonDTO applicant = new GetAllPersonDTO();
                            applicant.setName(applicantMerge);
                            applicant.setCountry(person.getCountry());
                            applicant.setAddress(person.getAddress());
                            applicant.setRemark(person.getRemark());
                            applicant.setType(personType);
                            applicantMergeList.add(applicant);
                        }
                    }
                } else if (person.getType() == 2) {
                    List<String> inventorMerges = JSONArray.parseArray(person.getMergedName(), String.class);
                    if (!CollectionUtils.isEmpty(inventorMerges)) {
                        for (String inventorMerge : inventorMerges) {
                            GetAllPersonDTO inventor = new GetAllPersonDTO();
                            inventor.setName(inventorMerge);
                            inventor.setCountry(person.getCountry());
                            inventor.setAddress(person.getAddress());
                            inventor.setRemark(person.getRemark());
                            inventor.setType(personType);
                            inventorMergeList.add(inventor);
                        }
                    }
                }
            }
        }
        //申请人/权利人
        if (!CollectionUtils.isEmpty(personDTOList) && !CollectionUtils.isEmpty(applicantMergeList)) {
            for (GetAllPersonDTO applicantMerge : applicantMergeList) {
                personDTOList.removeIf(personDTO -> personDTO.getName().equals(applicantMerge.getName()));
            }
        }
        //发明人
        if (!CollectionUtils.isEmpty(inventorDTOS) && !CollectionUtils.isEmpty(inventorMergeList)) {
            for (GetAllPersonDTO inventorMerge : inventorMergeList) {
                inventorDTOS.removeIf(inventor -> inventor.getName().equals(inventorMerge.getName()));
            }
        }

        //申请人/权利人、发明人返回数据
        List<GetAllPersonDTO> list = new ArrayList<>();
        if (type == 0) {
            list.addAll(mergeList);
            list.addAll(personDTOList);
        } else {
            list.addAll(mergeList);
            list.addAll(inventorDTOS);
        }

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

        Records records = new Records();
        records.setCurrent(pageNum);
        records.setSize(pageSize);
        records.setData(collect);
        records.setTotal((long) list.size());
        return records;
    }

    @Transactional(propagation = Propagation.REQUIRED, rollbackFor = Throwable.class)
    public Integer delMergedName(MergedNameVO vo) throws IOException {
        Integer type = vo.getType();
        String delName = vo.getDelName();
        String name = vo.getName();
        Integer projectId = vo.getProjectId();
        MergePerson mergePerson = mergePersonMapper.selectOne(new LambdaQueryWrapper<MergePerson>()
                .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();

            SearchRequest.Builder builder = new SearchRequest.Builder();
            //设置查询索引
            builder.index("patent");
            List<Query> queries = new ArrayList<>();
            List<Query> mustQueries = new ArrayList<>();
            if (type == 0) {
                Query q1 = QueryBuilders.term(i -> i.field("applicant.name.key").value(delName));
                Query query1 = QueryBuilders.nested(i -> i.path("applicant").query(q1));
                Query q2 = QueryBuilders.term(i -> i.field("right_holder.name.key").value(delName));
                Query query2 = QueryBuilders.nested(i -> i.path("right_holder").query(q2));
                queries.add(query1);
                queries.add(query2);
                Query q3 = QueryBuilders.term(i -> i.field("merge_applicant.name.raw").value(name));
                Query query3 = QueryBuilders.nested(i -> i.path("merge_applicant").query(q3));
                Query q4 = QueryBuilders.term(i -> i.field("merge_right_holder.name.raw").value(name));
                Query query4 = QueryBuilders.nested(i -> i.path("merge_right_holder").query(q4));
                mustQueries.add(query3);
                mustQueries.add(query4);
            } else {
                Query q = QueryBuilders.term(i -> i.field("inventor.name.key").value(delName));
                Query query = QueryBuilders.nested(i -> i.path("inventor").query(q));
                queries.add(query);
                Query q1 = QueryBuilders.term(i -> i.field("merge_inventor.name.raw").value(name));
                Query query1 = QueryBuilders.nested(i -> i.path("merge_inventor").query(q1));
                queries.add(query1);
            }
            Query query = QueryBuilders.bool(i -> i.must(mustQueries).should(queries));
            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);
                    esService.delMergePerson(patent, id, type, mergePerson.getName());
                }
            }
        }
        return mergePerson.getId();
    }

    @Transactional(propagation = Propagation.REQUIRED, rollbackFor = Throwable.class)
    public Integer delMergePerson(MergePersonIdVO vo) throws IOException {
        Integer type = vo.getType();
        MergePerson mergePerson = mergePersonMapper.selectById(vo.getId());
        String name = mergePerson.getName();
        if (ObjectUtil.isNotEmpty(mergePerson)) {
            LambdaQueryWrapper<MergePerson> wrapper = new LambdaQueryWrapper<MergePerson>()
                    .eq(BaseEntity::getId, vo.getId());
            this.remove(wrapper);

            SearchRequest.Builder builder = new SearchRequest.Builder();
            //设置查询索引
            builder.index("patent");
            List<Query> queries = new ArrayList<>();
            if (type == 0) {
                Query q1 = QueryBuilders.term(i -> i.field("merge_applicant.name.raw").value(name));
                Query query1 = QueryBuilders.nested(i -> i.path("merge_applicant").query(q1));
                Query q2 = QueryBuilders.term(i -> i.field("merge_right_holder.name.raw").value(name));
                Query query2 = QueryBuilders.nested(i -> i.path("merge_right_holder").query(q2));
                queries.add(query1);
                queries.add(query2);
            } else {
                Query q = QueryBuilders.term(i -> i.field("merge_inventor.name.raw").value(name));
                Query query3 = QueryBuilders.nested(i -> i.path("merge_inventor").query(q));
                queries.add(query3);
            }
            Query query = QueryBuilders.bool(i -> i.must(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);
                    esService.delMergePerson(patent, id, type, mergePerson.getName());
                }
            }
        }
        return vo.getId();
    }

    /**
     * 获取所有国家列表查询
     * @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;
    }
}