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

package cn.cslg.pas.service.business;

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.es.Patent;
import cn.cslg.pas.domain.es.PatentMergePerson;
import cn.cslg.pas.domain.es.PersonAddress;
import cn.cslg.pas.exception.UnLoginException;
import cn.cslg.pas.mapper.MergePersonMapper;
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;

    @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);
                List<PatentMergePerson> mergeApplicants = patent.getMergeApplicant();
                mergePersonList.addAll(mergeApplicants);
                patent.setMergeApplicant(mergePersonList);
                patent.setMergeRightHolder(mergePersonList);
                esService.updateMergePerson(patent, id);
            }
        }
        return person.getId();
    }

    @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();

            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);
                    List<PatentMergePerson> mergeApplicants = patent.getMergeApplicant();
                    if (!name.equals(vo.getName())) {
                        for (PatentMergePerson mergeApplicant : mergeApplicants) {
                            if (mergeApplicant.getName().equals(name)) {
                                mergeApplicant.setName(vo.getName());
                            }
                        }
                    }
                    patent.setMergeApplicant(mergeApplicants);
                    patent.setMergeRightHolder(mergeApplicants);
                    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();
        Integer pageNum = vo.getPageNum();
        Integer pageSize = vo.getPageSize();
        Integer type = vo.getType();
        String searchCondition = "";
        if (type == 0 && StringUtils.isNotEmpty(vo.getName())) {
            searchCondition = searchCondition + "PA = " + 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();
        long total = response.hits().total().value();
        List<GetEsAllPersonDTO> personDTOS = new ArrayList<>();
        for (Hit<Patent> hit : hits) {
            Patent esMess = hit.source();
            PersonAddress applicantAddr = null;
            GetEsAllPersonDTO personDTO = new GetEsAllPersonDTO();
            if (ObjectUtil.isNotEmpty(esMess.getApplicantAddr())) {
                applicantAddr = esMess.getApplicantAddr();
                personDTO.setAddress(applicantAddr.getAddress());
                personDTO.setCountry(applicantAddr.getCountry());
            }
            personDTO.setApplicant(esPatentService.loadName(esMess.getApplicant()));
            personDTO.setRightHolder(esPatentService.loadName(esMess.getRightHolder()));
            personDTO.setInventor(esPatentService.loadName(esMess.getInventor()));
            personDTOS.add(personDTO);
        }
        List<String> applicants = new ArrayList<>();
        List<String> inventors = new ArrayList<>();
        for (GetEsAllPersonDTO personDTO : personDTOS) {
            applicants.addAll(personDTO.getApplicant());
            inventors.addAll(personDTO.getInventor());
        }
        List<String> applicantList = applicants.stream().distinct().collect(Collectors.toList());
        List<String> inventorList = inventors.stream().distinct().collect(Collectors.toList());

        IPage<MergePerson> page = new Page<>(vo.getPageNum(), vo.getPageSize());
        LambdaQueryWrapper<MergePerson> wrapper = new LambdaQueryWrapper<MergePerson>()
                .eq(StringUtils.isNotEmpty(vo.getProjectId().toString()), MergePerson::getProjectId, vo.getProjectId());
        IPage<MergePerson> record = mergePersonMapper.selectPage(page, wrapper);
        List<String> applicantMergeList = new ArrayList<>();
        List<String> inventorMergeList = new ArrayList<>();
        for (MergePerson person : record.getRecords()) {
            if (person.getType() == 0) {
                applicantMergeList = JSONArray.parseArray(person.getMergedName(), String.class);
            } else if (person.getType() == 2) {
                inventorMergeList = JSONArray.parseArray(person.getMergedName(), String.class);
            }
        }
        applicantList.removeAll(applicantMergeList);
        inventorList.removeAll(inventorMergeList);
        List<GetAllPersonDTO> applicantDTOS = new ArrayList<>();
        List<GetAllPersonDTO> inventorDTOS = new ArrayList<>();
        for (String applicant : applicantList) {
            GetAllPersonDTO dto = new GetAllPersonDTO();
            dto.setName(applicant);
            dto.setType(0);
            applicantDTOS.add(dto);
        }
        for (String inventor : inventorList) {
            GetAllPersonDTO dto = new GetAllPersonDTO();
            dto.setName(inventor);
            dto.setType(2);
            inventorDTOS.add(dto);
        }

        Records records = new Records();
        records.setCurrent(vo.getPageNum().longValue());
        records.setSize(vo.getPageSize().longValue());
        if (vo.getType() == 0) {
            int size = applicantDTOS.size();
            records.setData(applicantDTOS.stream().limit(vo.getPageSize()).collect(Collectors.toList()));
            if (total >= size) {
                records.setTotal((long) size);
            } else {
                records.setTotal(total);
            }
        } else if (vo.getType() == 2) {
            int size = inventorDTOS.size();
            records.setData(inventorDTOS.stream().limit(vo.getPageSize()).collect(Collectors.toList()));
            if (total >= size) {
                records.setTotal((long) size);
            } else {
                records.setTotal(total);
            }
        }
        return records;
    }


    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::getMergedName, 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();
    }

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