PAS/src/main/java/cn/cslg/pas/service/business/es/EsPatentService.java

package cn.cslg.pas.service.business.es;

import cn.cslg.pas.common.core.base.IfConstant;
import cn.cslg.pas.common.dto.*;
import cn.cslg.pas.common.dto.business.ContentDetailDTO;
import cn.cslg.pas.common.dto.es.EsCustomFieldValueDTO;
import cn.cslg.pas.common.model.addPatentToReport.PatentNoWithIdVO;
import cn.cslg.pas.common.model.cronModel.Records;
import cn.cslg.pas.common.model.cronModel.SystemFile;
import cn.cslg.pas.common.model.es.GetVectorVO;
import cn.cslg.pas.common.model.request.MapRequest;
import cn.cslg.pas.common.model.request.OrderDTO;
import cn.cslg.pas.common.model.request.QueryRequest;
import cn.cslg.pas.common.model.request.StringRequest;
import cn.cslg.pas.common.utils.FormatUtil;
import cn.cslg.pas.common.utils.PatentRightUtils;
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.ContentVO;
import cn.cslg.pas.common.vo.EsConfigVO;
import cn.cslg.pas.common.vo.PatentPageMessageVO;
import cn.cslg.pas.common.vo.PatentWithIdVO;
import cn.cslg.pas.common.vo.business.PatentKinDetailVO;
import cn.cslg.pas.common.vo.business.PatentKinVO;
import cn.cslg.pas.common.vo.business.PatentNoVO;
import cn.cslg.pas.common.vo.business.SelectProductVO;
import cn.cslg.pas.common.vo.es.EsPatentCommonVO;
import cn.cslg.pas.domain.es.*;
import cn.cslg.pas.exception.ExceptionEnum;
import cn.cslg.pas.exception.XiaoShiException;
import cn.cslg.pas.mapper.ProductCategoryMapper;
import cn.cslg.pas.mapper.ProductMapper;
import cn.cslg.pas.service.business.CommonService;
import cn.cslg.pas.service.business.ProductService;
import cn.cslg.pas.service.common.FileManagerService;
import cn.cslg.pas.service.permissions.PermissionService;
import cn.cslg.pas.service.query.FormatQueryService;
import co.elastic.clients.elasticsearch.ElasticsearchClient;
import co.elastic.clients.elasticsearch._types.ElasticsearchException;
import co.elastic.clients.elasticsearch._types.SortOptions;
import co.elastic.clients.elasticsearch._types.SortOrder;
import co.elastic.clients.elasticsearch._types.aggregations.Aggregate;
import co.elastic.clients.elasticsearch._types.aggregations.StringTermsBucket;
import co.elastic.clients.elasticsearch._types.query_dsl.Query;
import co.elastic.clients.elasticsearch._types.query_dsl.QueryBuilders;
import co.elastic.clients.elasticsearch.core.DeleteByQueryRequest;
import co.elastic.clients.elasticsearch.core.DeleteResponse;
import co.elastic.clients.elasticsearch.core.SearchRequest;
import co.elastic.clients.elasticsearch.core.SearchResponse;
import co.elastic.clients.elasticsearch.core.search.FieldCollapse;
import co.elastic.clients.elasticsearch.core.search.Hit;
import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.JSONArray;
import com.alibaba.fastjson2.JSONObject;
import lombok.RequiredArgsConstructor;
import org.apache.commons.lang3.ObjectUtils;
import org.apache.commons.lang3.StringUtils;
import org.apache.ibatis.javassist.runtime.Desc;
import org.springframework.beans.BeanUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Lazy;
import org.springframework.stereotype.Service;
import org.springframework.util.CollectionUtils;

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

@Service
@RequiredArgsConstructor(onConstructor_ = {@Lazy})
public class EsPatentService {

    private final ElasticsearchClient client;
    private final FormatQueryService formatQueryService;
    @Autowired
    private PermissionService permissionService;

    @Autowired
    private FileManagerService fileManagerService;

    @Autowired
    private ProductMapper productMapper;

    @Autowired
    private ProductCategoryMapper productCategoryMapper;

    @Autowired
    private ProductService productService;

    @Autowired
    @Lazy
    private EsService esService;

    /**
     * 根据专利号查询专利详情
     *
     * @param vo
     * @return
     * @throws IOException
     */
    public PatentColumnDTO selectPatentDetail(PatentNoVO vo) throws IOException {
        PatentColumnDTO dto = new PatentColumnDTO();
        SearchRequest.Builder builder = new SearchRequest.Builder();
        //设置查询索引
        builder.index("patent");
        Query q1 = QueryBuilders.term(t -> t.field("patent_no.keyword").value(vo.getPatentNo()));
        Query query = QueryBuilders.bool(i -> i.should(q1));
        builder.query(query);
        SearchResponse<Patent> response = null;
        try {
            response = client.search(builder.build(), Patent.class);
        } catch (Exception e) {
            throw new XiaoShiException(ExceptionEnum.BUSINESS_ERROR, "ES检索失败");
        }
        List<Hit<Patent>> hits = response.hits().hits();
        for (Hit<Patent> hit : hits) {
            Patent esMess = hit.source();
            dto = esService.getPatentColumnDTO(esMess, vo.getProjectId(), hit.id(), "");
            //格式化权利要求
            List<Text> claims = dto.getClaim();
            if (claims != null && claims.size() > 0) {
                claims.forEach(item -> {
                    item.setTextContent(PatentRightUtils.getFormatClaim(item.getTextContent(), item.getLanguage()));
                });
            }
            if (esMess.getPatentNo().equals(vo.getPatentNo())) {
                break;
            }
        }
        dto.setPictureGuid(FormatUtil.getPictureFormat(dto.getAppNo()));
        List<LegalEvent> legalEvents = this.getLegalEvents(vo.getPatentNo());
        dto.setLegalEvents(legalEvents);
        return dto;
    }

    public List<LegalEvent> getLegalEvents(String patentNo) throws IOException {
        List<LegalEvent> events = new ArrayList<>();
        SearchRequest.Builder builder = new SearchRequest.Builder();
        //设置查询索引
        builder.index("legal_event");
        List<Query> queries = new ArrayList<>();

        Query q1 = QueryBuilders.term(i -> i.field("app_no").value(patentNo));
        queries.add(q1);

        Query q2 = QueryBuilders.term(i -> i.field("public_no").value(patentNo));
        queries.add(q2);

        Query q3 = QueryBuilders.term(i -> i.field("grant_no").value(patentNo));
        queries.add(q3);

        if (!CollectionUtils.isEmpty(queries)) {
            Query query = QueryBuilders.bool(i -> i.should(queries));
            builder.query(query);
            SearchResponse<LegalEvent> response = null;
            try {
                response = client.search(builder.build(), LegalEvent.class);
            } catch (Exception e) {
                throw new XiaoShiException(ExceptionEnum.BUSINESS_ERROR, "ES检索失败");
            }
            List<Hit<LegalEvent>> hits = response.hits().hits();
            for (Hit<LegalEvent> hit : hits) {
                LegalEvent event = hit.source();
                events.add(event);
            }
        }
        events = events.stream().sorted(Comparator.comparing(LegalEvent::getEventDate).reversed()).collect(Collectors.toList());
        return events;
    }

    //通用返回摘要、标题、权利要求具体内容
    public ContentVO loadContent(List<Text> list) {
        ContentVO contentVO = new ContentVO();
        String content = StringUtils.strip(JSON.toJSONString(list), "[]");
        ContentDetailDTO contentDetailDTO = JSONObject.parseObject(content, ContentDetailDTO.class);
        contentVO.setContent(contentDetailDTO.getTextContent());
        return contentVO;
    }

    //通用返回申请人、权利人、发明人
    public List<String> loadName(List<PatentPerson> list) {
        List<String> collect = new ArrayList<>();
        if (!CollectionUtils.isEmpty(list)) {
            collect = list.stream().filter(i -> StringUtils.isNotEmpty(i.getName())).map(PatentPerson::getName).collect(Collectors.toList());
        }
        return collect;
    }

    //通用返回合并申请人、合并权利人、合并发明人
    public List<String> loadMergeName(List<PatentMergePerson> list) {
        List<String> collect = new ArrayList<>();
        if (!CollectionUtils.isEmpty(list)) {
            collect = list.stream().map(PatentMergePerson::getName).distinct().collect(Collectors.toList());
        }
        return collect;
    }

    //获取合并申请人
    public List<String> getMergeApp(Integer projectId, String id) throws IOException {
        SearchRequest.Builder builder = new SearchRequest.Builder();
        //设置查询索引
        builder.index("patent");
        Query q1 = QueryBuilders.term(i -> i.field("merge_applicant.project_id").value(projectId));
        Query exist1 = QueryBuilders.exists(i -> i.field("merge_applicant"));
        Query bool = QueryBuilders.bool(i -> i.must(q1, exist1));
        Query nested = QueryBuilders.nested(i -> i.path("merge_applicant").query(bool));
        Query ids = QueryBuilders.ids(i -> i.values(Arrays.asList(id)));
        Query query = QueryBuilders.hasParent(i -> i.parentType("patent").query(ids));
        Query q = QueryBuilders.bool(i -> i.must(nested, query));
        builder.query(q);
        SearchResponse<Patent> response = null;
        try {
            response = client.search(builder.build(), Patent.class);
        } catch (IOException e) {
            throw new XiaoShiException(ExceptionEnum.BUSINESS_ERROR, "ES检索失败");
        }
        List<Hit<Patent>> hits = response.hits().hits();
        List<PatentMergePerson> list = new ArrayList<>();
        for (Hit<Patent> hit : hits) {
            Patent patent = hit.source();
            if (!CollectionUtils.isEmpty(patent.getMergeApplicant())) {
                list.addAll(patent.getMergeApplicant());
            }
        }
        List<String> data = new ArrayList<>();
        if (!CollectionUtils.isEmpty(list)) {
            data = this.loadMergeName(list);
        }
        return data;
    }

    //获取合并权利人
    public List<String> getMergeRight(Integer projectId, String id) throws IOException {
        SearchRequest.Builder builder = new SearchRequest.Builder();
        //设置查询索引
        builder.index("patent");
        Query q1 = QueryBuilders.term(i -> i.field("merge_right_holder.project_id").value(projectId));
        Query exist1 = QueryBuilders.exists(i -> i.field("merge_right_holder"));
        Query bool = QueryBuilders.bool(i -> i.must(q1, exist1));
        Query nested = QueryBuilders.nested(i -> i.path("merge_right_holder").query(bool));
        Query ids = QueryBuilders.ids(i -> i.values(Arrays.asList(id)));
        Query query = QueryBuilders.hasParent(i -> i.parentType("patent").query(ids));
        Query q = QueryBuilders.bool(i -> i.must(nested, query));
        builder.query(q);
        SearchResponse<Patent> response = null;
        try {
            response = client.search(builder.build(), Patent.class);
        } catch (IOException e) {
            throw new XiaoShiException(ExceptionEnum.BUSINESS_ERROR, "ES检索失败");
        }
        List<Hit<Patent>> hits = response.hits().hits();
        List<PatentMergePerson> list = new ArrayList<>();
        for (Hit<Patent> hit : hits) {
            Patent patent = hit.source();
            if (!CollectionUtils.isEmpty(patent.getMergeRightHolder())) {
                list.addAll(patent.getMergeRightHolder());
            }
        }
        List<String> data = new ArrayList<>();
        if (!CollectionUtils.isEmpty(list)) {
            data = this.loadMergeName(list);
        }
        return data;
    }

    //获取合并发明人
    public List<String> getMergeInventor(Integer projectId, String id) throws IOException {
        SearchRequest.Builder builder = new SearchRequest.Builder();
        //设置查询索引
        builder.index("patent");
        Query q1 = QueryBuilders.term(i -> i.field("merge_inventor.project_id").value(projectId));
        Query exist1 = QueryBuilders.exists(i -> i.field("merge_inventor"));
        Query bool = QueryBuilders.bool(i -> i.must(q1, exist1));
        Query nested = QueryBuilders.nested(i -> i.path("merge_inventor").query(bool));
        Query ids = QueryBuilders.ids(i -> i.values(Arrays.asList(id)));
        Query query = QueryBuilders.hasParent(i -> i.parentType("patent").query(ids));
        Query q = QueryBuilders.bool(i -> i.must(nested, query));
        builder.query(q);
        SearchResponse<Patent> response = null;
        try {
            response = client.search(builder.build(), Patent.class);
        } catch (IOException e) {
            throw new XiaoShiException(ExceptionEnum.BUSINESS_ERROR, "ES检索失败");
        }
        List<Hit<Patent>> hits = response.hits().hits();
        List<PatentMergePerson> list = new ArrayList<>();
        for (Hit<Patent> hit : hits) {
            Patent patent = hit.source();
            if (!CollectionUtils.isEmpty(patent.getMergeInventor())) {
                list.addAll(patent.getMergeInventor());
            }
        }
        List<String> data = new ArrayList<>();
        if (!CollectionUtils.isEmpty(list)) {
            data = this.loadMergeName(list);
        }
        return data;
    }

    /**
     * 获得中国专利pdf全文
     *
     * @param appNo
     * @return
     * @throws IOException
     */
    public List<InnerPatentPdfDTO> getTextPdf(String appNo) throws IOException {
        List<InnerPatentPdfDTO> list = new ArrayList<>();
        //公开说明书pdf
        String pdfFormat1 = FormatUtil.getPDFFormat(appNo, 0);

        //授权说明书pdf
        String pdfFormat2 = FormatUtil.getPDFFormat(appNo, 1);

        //查询文件是否存在
        List<SystemFile> systemFiles = new ArrayList<>();
        try {
            String res = fileManagerService.getSystemFileFromFMS(Arrays.asList(pdfFormat1, pdfFormat2));
            systemFiles = com.alibaba.fastjson.JSONObject.parseArray(res, SystemFile.class);
        } catch (Exception e) {

        }
        if (!CollectionUtils.isEmpty(systemFiles)) {
            SystemFile systemFile1 = systemFiles.stream().filter(item -> item.getGuid().equals(pdfFormat1)).findFirst().orElse(null);
            SystemFile systemFile2 = systemFiles.stream().filter(item -> item.getGuid().equals(pdfFormat2)).findFirst().orElse(null);
            if (systemFile1 != null) {
                InnerPatentPdfDTO dto = new InnerPatentPdfDTO();
                dto.setPdfGuid(pdfFormat1);
                dto.setType(0);
                list.add(dto);
            }
            if (systemFile2 != null) {
                InnerPatentPdfDTO dto = new InnerPatentPdfDTO();
                dto.setPdfGuid(pdfFormat2);
                dto.setType(1);
                list.add(dto);
            }
        }
        return list;
    }

    /**
     * 获取附图
     *
     * @param appNo
     * @return
     */
    public List<String> getFigure(String appNo) throws IOException {
        List<String> list = new ArrayList<>();
        String guids = fileManagerService.getPatentPictureGuids(appNo);
        if (StringUtils.isNotEmpty(guids)) {
            JSONObject jsonObject = JSONObject.parseObject(guids);
            String data = jsonObject.get("data").toString();
            if (StringUtils.isNotEmpty(data)) {
                list = JSONArray.parseArray(data, String.class);
            }
        }
        return list;
    }

    /**
     * 根据专利号查询出同族专利列表
     *
     * @param vo
     * @return
     * @throws IOException
     */
    public Records selectKinByPatentNo(PatentKinVO vo) throws IOException {
        //1.根据专利号查询出同族
        String no = vo.getNo();
        Integer pageNum = vo.getPageNum();
        Integer pageSize = vo.getPageSize();
        String type = vo.getType();
        String patentNo = vo.getPatentNo();
        SearchRequest.Builder builder = new SearchRequest.Builder();
        //设置查询索引
        builder.index("patent_family");
        //申请号
        Query q1 = QueryBuilders.term(t -> t.field("patent.app_no").value(no));
        //公开号
        Query q2 = QueryBuilders.term(t -> t.field("patent.public_no").value(no));
        //授权号
        Query q3 = QueryBuilders.term(t -> t.field("patent.grant_no").value(no));
        //同族类型
        Query q4 = QueryBuilders.term(t -> t.field("family_type").value(type));
        Query q = QueryBuilders.bool(i -> i.should(q1, q2, q3));
        Query bool = QueryBuilders.bool(i -> i.must(q4, q));
        builder.query(bool);
        //分页
        if (pageNum > 0 && pageSize > 0) {
            builder.from((pageNum - 1) * pageSize).size(pageSize);
        }
        SearchResponse<PatentFamilyMessage> response = null;
        try {
            response = client.search(builder.build(), PatentFamilyMessage.class);
        } catch (Exception e) {
            throw new XiaoShiException(ExceptionEnum.BUSINESS_ERROR, "ES检索失败");
        }
        List<Hit<PatentFamilyMessage>> hits = response.hits().hits();
        List<PatentKinDTO> kinDTOS = new ArrayList<>();
        for (Hit<PatentFamilyMessage> hit : hits) {
            PatentFamilyMessage familyMessage = hit.source();
            List<FamilyPatent> patentList = familyMessage.getPatent();
            if (!CollectionUtils.isEmpty(patentList)) {
                for (FamilyPatent familyPatent : patentList) {
                    PatentKinDetailVO kinDetailVO = new PatentKinDetailVO();
                    kinDetailVO.setPageNum(vo.getPageNum());
                    kinDetailVO.setPageSize(vo.getPageSize());
                    kinDetailVO.setAppNo(familyPatent.getAppNo());
                    kinDetailVO.setPublicNo(familyPatent.getPublicNo());
                    kinDetailVO.setGrantNo(familyPatent.getGrantNo());
                    if (StringUtils.isNotEmpty(patentNo)) {
                        PatentKinDTO kinDTO = this.selectPatentKindDetail(kinDetailVO, patentNo)
                                .stream().findFirst().orElse(null);
                        if (kinDTO != null) {
                            kinDTOS.add(kinDTO);
                        }
                        break;
                    } else {
                        PatentKinDTO kinDTO = this.selectPatentKindDetail(kinDetailVO, patentNo)
                                .stream().findFirst().orElse(null);
                        if (kinDTO != null) {
                            kinDTOS.add(kinDTO);
                        }
                    }
                }
            }
        }
        Records records = new Records();
        records.setCurrent(vo.getPageNum().longValue());
        records.setSize(vo.getPageSize().longValue());
        records.setData(kinDTOS);
        records.setTotal(Long.valueOf(String.valueOf(kinDTOS.size())));
        return records;
    }

    public List<PatentKinDTO> selectPatentKindDetail(PatentKinDetailVO vo, String patentNo) throws IOException {
        Integer pageNum = vo.getPageNum();
        Integer pageSize = vo.getPageSize();
        List<PatentKinDTO> list = new ArrayList<>();
        SearchRequest.Builder builder = new SearchRequest.Builder();
        //设置查询索引
        builder.index("patent");
        //申请号
        Query q1 = null;
        if (StringUtils.isNotEmpty(vo.getAppNo())) {
            q1 = QueryBuilders.term(t -> t.field("app_no.keyword").value(vo.getAppNo()));
        }
        //公开号
        Query q2 = null;
        if (StringUtils.isNotEmpty(vo.getPublicNo())) {
            q2 = QueryBuilders.term(t -> t.field("public_no.keyword").value(vo.getPublicNo()));
        }
        //授权号
//        Query q3 = QueryBuilders.term(t -> t.field("patent_no.keyword").value(vo.getGrantNo()));
        Query bool = null;
        Query query1 = q1;
        Query query2 = q2;
        if (StringUtils.isNotEmpty(patentNo)) {
            String str = "*";
            String s = str.concat(patentNo).concat("*");
            Query query = QueryBuilders.wildcard(i -> i.field("patent_no.keyword").value(s));
            if (query1 != null && query2 == null) {
                bool = QueryBuilders.bool(i -> i.should(query1).must(query));
            } else if (query2 != null && query1 == null) {
                bool = QueryBuilders.bool(i -> i.should(query2).must(query));
            } else {
                bool = QueryBuilders.bool(i -> i.should(query1, query2).must(query));
            }
        } else {
            if (query1 != null && query2 == null) {
                bool = QueryBuilders.bool(i -> i.should(query1));
            } else if (query2 != null && query1 == null) {
                bool = QueryBuilders.bool(i -> i.should(query2));
            } else {
                bool = QueryBuilders.bool(i -> i.should(query1, query2));
            }
        }

        builder.query(bool);
        //分页
//        if (pageNum > 0 && pageSize > 0) {
//            builder.from((pageNum - 1) * pageSize).size(pageSize);
//        }
        SearchResponse<Patent> response = null;
        try {
            response = client.search(builder.build(), Patent.class);
        } catch (Exception e) {
            throw new XiaoShiException(ExceptionEnum.BUSINESS_ERROR, "ES检索失败");
        }
        List<Hit<Patent>> hits = response.hits().hits();
        for (Hit<Patent> hit : hits) {
            PatentKinDTO kinDTO = new PatentKinDTO();
            Patent patent = hit.source();
            if (patent != null) {
                kinDTO.setPatentNo(patent.getPatentNo());
                kinDTO.setAppNo(patent.getAppNo());
                kinDTO.setPublicNo(patent.getPublicNo());
                kinDTO.setGrantNo(patent.getGrantNo());
                kinDTO.setTitle(patent.getTitle());
                kinDTO.setAbstractStr(patent.getAbstractStr());
                kinDTO.setApplicant(this.loadName(patent.getApplicant()));
                kinDTO.setRightHolder(this.loadName(patent.getRightHolder()));
                kinDTO.setPictureGuid(FormatUtil.getPictureFormat(kinDTO.getAppNo()));
                list.add(kinDTO);
            }
        }
        return list;
    }

    /**
     * 根据专利号查询出商品化专利
     *
     * @param vo
     * @return
     * @throws IOException
     */
    public Object selectProductByPatentNo(SelectProductVO vo) throws Exception {
        String patentNo = vo.getPatentNo();
        QueryRequest queryRequest = new QueryRequest();
        if (ObjectUtils.isNotEmpty(vo.getQueryRequest())) {
            queryRequest = vo.getQueryRequest();
        }
        List<Integer> productIds = new ArrayList<>();
        SearchRequest.Builder builder = new SearchRequest.Builder();
        //设置查询索引
        builder.index("patent");
        //申请号
        Query q1 = QueryBuilders.term(t -> t.field("app_no.keyword").value(patentNo));
        //公开号
        Query q2 = QueryBuilders.term(t -> t.field("public_no.keyword").value(patentNo));
        //授权号
        Query q3 = QueryBuilders.term(t -> t.field("grant_no.keyword").value(patentNo));
        Query bool = QueryBuilders.bool(i -> i.should(q1, q2, q3));
        Query q = QueryBuilders.exists(i -> i.field("product_id"));
        Query query = QueryBuilders.hasParent(parent -> parent.parentType("patent").query(bool));
        Query bool1 = QueryBuilders.bool(i -> i.must(q, query));
        builder.query(bool1);

        SearchResponse<Patent> response = null;
        try {
            response = client.search(builder.build(), Patent.class);
        } catch (Exception e) {
            throw new XiaoShiException(ExceptionEnum.BUSINESS_ERROR, "ES检索失败");
        }
        List<Hit<Patent>> hits = response.hits().hits();
        for (Hit<Patent> hit : hits) {
            Patent patent = hit.source();
            if (patent.getProductId() != null) {
                productIds.add(patent.getProductId());
            }
        }

        queryRequest.setProductIds(productIds.stream().distinct().collect(Collectors.toList()));
        return productService.selectProduct(queryRequest);
    }

    /**
     * 根据专利号批量查询专利
     *
     * @param patentNos
     * @return
     * @throws Exception
     */
    public List<Patent> getPatentsByNo(List<String> patentNos, Boolean ifGetAll, Long current, Long size) throws Exception {
        List<Patent> patentList = new ArrayList<>();
        if (patentNos == null || patentNos.size() == 0) {
            return patentList;
        }
        SearchRequest.Builder builder = new SearchRequest.Builder();
        //设置查询索引
        builder.index("patent");
        List<Query> querys = new ArrayList<>();
        for (String patentNo : patentNos) {
            Query q1 = QueryBuilders.term(t -> t.field("patent_no.keyword").value(patentNo));
            Query query = QueryBuilders.bool(i -> i.should(q1));
            querys.add(query);
        }
        Query finalQuery = QueryBuilders.bool((i -> i.should(querys)));
        builder.query(finalQuery);
        if (!ifGetAll) {
            List<String> reSources = this.rePatentSource();
            builder.source(sourceOptionsBuilder -> sourceOptionsBuilder
                    .filter(fieldSourceBuilder -> fieldSourceBuilder
                            .includes(reSources)));
        }
        if (current != null && size != null && current > 0 && size > 0) {
            builder.from((current.intValue() - 1) * size.intValue()).size(size.intValue());
        } else {
            builder.from(0).size(10000);
        }
        SearchResponse<Patent> response = null;
        try {
            response = client.search(builder.build(), Patent.class);
        } catch (Exception e) {
            throw new XiaoShiException(ExceptionEnum.BUSINESS_ERROR, "ES检索失败");
        }
        List<Hit<Patent>> hits = response.hits().hits();
        if (hits != null && hits.size() > 0) {
            hits.forEach(item -> {
                        Patent patent = item.source();
                        patentList.add(patent);
                    }
            );
        }
        return patentList;
    }

    public List<PatentColumnDTO> getPatentsByNo1(List<String> patentNos, Boolean ifGetAll, Long current, Long size, Integer projectId) throws Exception {
        List<PatentColumnDTO> patentList = new ArrayList<>();
        if (patentNos == null || patentNos.size() == 0) {
            return patentList;
        }
        SearchRequest.Builder builder = new SearchRequest.Builder();
        //设置查询索引
        builder.index("patent");
        List<Query> querys = new ArrayList<>();
        for (String patentNo : patentNos) {
            Query q1 = QueryBuilders.term(t -> t.field("app_no.keyword").value(patentNo));
            //公开号
            Query q2 = QueryBuilders.term(t -> t.field("public_no.keyword").value(patentNo));
            //授权号
            Query q3 = QueryBuilders.term(t -> t.field("grant_no.keyword").value(patentNo));
            Query query = QueryBuilders.bool(i -> i.should(q1, q2, q3));
            querys.add(query);
        }
        Query finalQuery = QueryBuilders.bool((i -> i.should(querys)));
        builder.query(finalQuery);
        if (!ifGetAll) {
            List<String> reSources = this.rePatentSource();
            builder.source(sourceOptionsBuilder -> sourceOptionsBuilder
                    .filter(fieldSourceBuilder -> fieldSourceBuilder
                            .includes(reSources)));
        }
        if (current != null && size != null && current > 0 && size > 0) {
            builder.from((current.intValue() - 1) * size.intValue()).size(size.intValue());
        } else {
            builder.from(0).size(10000);
        }
        SearchResponse<Patent> response = null;
        try {
            response = client.search(builder.build(), Patent.class);
        } catch (Exception e) {
            throw new XiaoShiException(ExceptionEnum.BUSINESS_ERROR, "ES检索失败");
        }
        List<Hit<Patent>> hits = response.hits().hits();
        if (hits != null && hits.size() > 0) {
            hits.forEach(item -> {
                        Patent patent = item.source();
                        String id = item.id();
                        PatentColumnDTO columnDTO = esService.getPatentColumnDTO(patent, projectId, id, "1");
                        patentList.add(columnDTO);
                    }
            );
        }
        return patentList;
    }


    private List<String> rePatentSource() {
        List<String> rePatentSource = new ArrayList<>();
        rePatentSource.add("patent_no");
        rePatentSource.add("app_no");
        rePatentSource.add("app_date");
        rePatentSource.add("public_no");
        rePatentSource.add("public_date");
        rePatentSource.add("grant_no");
        rePatentSource.add("grant_date");
        rePatentSource.add("title");
        rePatentSource.add("project_id");
        rePatentSource.add("applicant");
        rePatentSource.add("abstract_str");
        return rePatentSource;
    }


    /**
     * 检索上一页下一页信息
     *
     * @param queryRequest 检索条件
     * @return
     */
    public Records getPatentPageMessage(QueryRequest queryRequest) throws Exception {
        List<PatentPageMessageVO> patentPageMessageVOS = new ArrayList<>();

        Long current = queryRequest.getCurrent();
        Long size = queryRequest.getSize();
        EsPatentCommonVO esPatentCommonVO = esService.tranPatentRequestToComVO(queryRequest);
        esPatentCommonVO.setStartNum(current);
        esPatentCommonVO.setEndNum(current + size);
        esPatentCommonVO.setCurrent(null);
        esPatentCommonVO.setSize(null);
        SearchRequest.Builder builder = esService.getCommonPatent(esPatentCommonVO);
        Records records = new Records();
        SearchResponse<Patent> response = null;
        try {
            response = client.search(builder.build(), Patent.class);
        } catch (Exception e) {
            throw new XiaoShiException(ExceptionEnum.BUSINESS_ERROR, "ES检索失败");
        }
        List<Hit<Patent>> hits = response.hits().hits();
        for (Hit<Patent> hit : hits) {
            PatentPageMessageVO patentPageMessageVO = new PatentPageMessageVO();
            patentPageMessageVO.setPatentNo(hit.source().getPatentNo());
            patentPageMessageVOS.add(patentPageMessageVO);
        }
        long total = 0L;
        if (StringUtils.isNotEmpty(esPatentCommonVO.getEsField())) {
            Aggregate aggregate = response.aggregations().get("count");
            total = aggregate.cardinality().value();
        } else {
            total = response.hits().total().value();
        }
        records.setTotal(total);

        records.setSize(size);
        records.setCurrent(current);
        records.setData(patentPageMessageVOS);
        return records;
    }

    /**
     * 检索上一页下一页信息
     *
     * @param queryRequest 检索条件
     * @return
     */
    public List<Patent> getPatentsWithNotNo(QueryRequest queryRequest, List<String> patentNos) throws Exception {
        List<Patent> patentList = new ArrayList<>();
        SearchRequest.Builder builder = new SearchRequest.Builder();
        Long current = queryRequest.getCurrent();
        Long size = queryRequest.getSize();
        //设置查询索引
        builder.index("patent");
        Query q = this.getQuery(queryRequest);

        Query reQuery = null;
        if (patentNos != null && patentNos.size() > 0) {
            List<Query> notInQuery = this.getNoNotInQuery(patentNos);
            reQuery = QueryBuilders.bool(i -> i.must(q).mustNot(notInQuery));
        } else {
            reQuery = QueryBuilders.bool(i -> i.must(q));
        }
        //4. 返回数据
        builder.query(reQuery);
        if (current > 0 && size > 0) {
            builder.from(current.intValue() - 1).size(size.intValue());
        }
        List<String> reSources = this.rePatentSource();
        builder.source(sourceOptionsBuilder -> sourceOptionsBuilder
                .filter(fieldSourceBuilder -> fieldSourceBuilder
                        .includes(reSources)));

        SearchResponse<Patent> response = null;
        try {
            response = client.search(builder.build(), Patent.class);
        } catch (Exception e) {
            throw new XiaoShiException(ExceptionEnum.BUSINESS_ERROR, "ES检索失败");
        }
        List<Hit<Patent>> hits = response.hits().hits();
        for (Hit<Patent> hit : hits) {
            if (hits != null && hits.size() > 0) {
                Patent patent = hit.source();
                patentList.add(patent);
            }
        }
        return patentList;
    }

    public Long getTotalNum(QueryRequest queryRequest) throws Exception {
        SearchRequest.Builder builder = new SearchRequest.Builder();
        //设置查询索引
        builder.index("patent");
        Query q = this.getQuery(queryRequest);
        //4. 返回数据
        Query reQuery = QueryBuilders.bool(i -> i.must(q));
        builder.query(reQuery);

        List<String> reSources = this.rePatentSource();
        builder.source(sourceOptionsBuilder -> sourceOptionsBuilder
                .filter(fieldSourceBuilder -> fieldSourceBuilder
                        .includes(reSources)));
        SearchResponse<Patent> response = null;
        try {
            response = client.search(builder.build(), Patent.class);
        } catch (Exception e) {
            throw new XiaoShiException(ExceptionEnum.BUSINESS_ERROR, "ES检索失败");
        }
        return response.hits().total().value();
    }


    public Query getQuery(QueryRequest queryRequest) throws Exception {
        String searchCondition = "";
        Integer projectId = queryRequest.getProjectId();
        Integer taskId = queryRequest.getTaskId();
        //判断表达式
        if (queryRequest instanceof StringRequest) {
            searchCondition = ((StringRequest) queryRequest).getSearchQuery();
        } else if (queryRequest instanceof MapRequest) {
            Map<String, Object> map = ((MapRequest) queryRequest).getSearchQuery();
            StringBuilder stringBuilder = new StringBuilder();
            for (String key : map.keySet()) {
                Object value = map.get(key);
                if (!"".contentEquals(stringBuilder)) {
                    stringBuilder = stringBuilder.append(" AND ").append(key).append("=").append(value);
                } else {
                    stringBuilder = stringBuilder.append(key).append("=").append(value);
                }
            }
            searchCondition = stringBuilder.toString();
        }
        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;
            }
        }
        List<EsCustomFieldValueDTO> customFields = queryRequest.getCustomFields();
        if (!CollectionUtils.isEmpty(customFields)) {
            String customFieldCondition = esService.parseCustomField(customFields, projectId, taskId);
            if (StringUtils.isNotEmpty(searchCondition)) {
                searchCondition = searchCondition + " AND " + customFieldCondition;
            } else {
                searchCondition = customFieldCondition;
            }
        }
        //1. 解析检索条件
        treeNode tree = expressManager.getInstance().Parse(searchCondition, false);
        //格式化检索式
        //3. 从es中检索数据
        Query q = formatQueryService.EsQueryToQuery((operateNode) tree, "patent", null);

        return q;
    }

    public List<Query> getNoNotInQuery(List<String> patentNos) {
        List<Query> queryList = new ArrayList<>();
        for (String patentNo : patentNos) {
            Query q1 = QueryBuilders.term(t -> t.field("patent_no.keyword").value(patentNo));
            queryList.add(q1);
        }
        return queryList;
    }

    public Query getEntireNotInQuery(EsPatentCommonVO commonVO) throws Exception {
        Integer projectId = commonVO.getProjectId();
        Integer productId = commonVO.getProductId();
        Integer taskId = commonVO.getTaskId();
        String searchCondition = commonVO.getSearchCondition();
        String productFrom = commonVO.getProductFrom();
        List<EsCustomFieldValueDTO> customFields = commonVO.getCustomFields();
        List<String> patentNos = commonVO.getIsDelete();

        if (!CollectionUtils.isEmpty(customFields)) {
            String customFieldCondition = esService.parseCustomField(customFields, projectId, taskId);
            if (StringUtils.isNotEmpty(searchCondition)) {
                searchCondition = searchCondition + " AND " + customFieldCondition;
            } else {
                searchCondition = customFieldCondition;
            }
        }
        String condition = esService.appendIdsCondition(searchCondition, taskId, productFrom, projectId, productId);

        Query q = null;
        if (StringUtils.isEmpty(condition)) {
            q = QueryBuilders.exists(i -> i.field("patent_no"));
        } else {
            //1. 解析检索条件
            treeNode tree = expressManager.getInstance().Parse(condition, false);
            //3. 从es中检索数据
            q = formatQueryService.EsQueryToQuery((operateNode) tree, "patent", projectId);
        }
        Query finalQ = q;
        Query reQuery = null;
        if (patentNos != null && patentNos.size() > 0) {
            List<Query> notInQuery = this.getNoNotInQuery(patentNos);
            reQuery = QueryBuilders.bool(i -> i.must(finalQ).mustNot(notInQuery));
        } else {
            reQuery = q;
        }
        return reQuery;
    }

    /**
     * 根据id查询
     *
     * @param ids
     * @return
     * @throws Exception
     */
    public List<Hit<Patent>> getById(List<String> ids) throws Exception {
        List<Hit<Patent>> patents = new ArrayList<>();
        SearchRequest.Builder builder = new SearchRequest.Builder();
        builder.index("patent");
        Query q = QueryBuilders.ids(i -> i.values(ids));
        builder.query(q);
        SearchResponse<Patent> response = null;
        try {
            response = client.search(builder.build(), Patent.class);
        } catch (Exception e) {
            throw new XiaoShiException(ExceptionEnum.BUSINESS_ERROR, "ES检索失败");
        }
        long total = response.hits().total().value();
        if (total > 0) {
            patents = response.hits().hits();
        }
        return patents;
    }

    public void removeById(String id) throws IOException {
        DeleteResponse deleteResponse = client.delete(deleteRequest ->
                deleteRequest.index("patent").id(id)
        );
    }


    public List<PatentNoWithIdVO> getPatentIdsWithNotNo(QueryRequest queryRequest, List<String> patentNos, Long startNum, Long endNum) throws Exception {
        List<PatentNoWithIdVO> patentWithIdVOS = new ArrayList<>();

        EsPatentCommonVO esPatentCommonVO = esService.tranPatentRequestToComVO(queryRequest);
        esPatentCommonVO.setIsDelete(patentNos);
        esPatentCommonVO.setStartNum(startNum);
        esPatentCommonVO.setEndNum(endNum);
        SearchRequest.Builder builder = esService.getCommonPatent(esPatentCommonVO);
        SearchResponse<Patent> response = null;
        try {
            response = client.search(builder.build(), Patent.class);
        } catch (Exception e) {
            throw new XiaoShiException(ExceptionEnum.BUSINESS_ERROR, "ES检索失败");
        }
        List<Hit<Patent>> hits = response.hits().hits();
        for (Hit<Patent> hit : hits) {
            if ((patentNos == null || patentNos.size() == 0) || (!patentNos.contains(hit.source().getPatentNo()))) {

                PatentNoWithIdVO patentWithIdVO = new PatentNoWithIdVO();
                patentWithIdVO.setId(hit.id());
                patentWithIdVO.setPatentNo(hit.source().getPatentNo());
                patentWithIdVOS.add(patentWithIdVO);
            }
        }
        return patentWithIdVOS;
    }

    //根据专利号模糊查询
    public List<Integer> getProjectIds(String patentNo) throws Exception {
        List<Integer> projectIds = new ArrayList<>();
        List<Patent> patentList = new ArrayList<>();
        SearchRequest.Builder builder = new SearchRequest.Builder();
        //设置查询索引
        builder.index("patent");

        String searchPatentNo = "*" + patentNo + "*";

        Query q1 = QueryBuilders.wildcard(i -> i.field("app_no.keyword").value(searchPatentNo));
        //公开号
        Query q2 = QueryBuilders.wildcard(t -> t.field("public_no.keyword").value(searchPatentNo));
        //授权号
        Query q3 = QueryBuilders.wildcard(t -> t.field("grant_no.keyword").value(searchPatentNo));
        Query query = QueryBuilders.bool(i -> i.should(q1, q2, q3));


        Query query1 = QueryBuilders.hasParent(i -> i.parentType("patent").query(query));

        Query query2 = QueryBuilders.exists(i -> i.field("project_id"));
        Query finalQuery = QueryBuilders.bool((i -> i.must(query1, query2)));
        builder.query(finalQuery);
        List<String> reSources = this.rePatentSource();
        builder.source(sourceOptionsBuilder -> sourceOptionsBuilder
                .filter(fieldSourceBuilder -> fieldSourceBuilder
                        .includes(reSources)));
        builder.from(0).size(1000);
        FieldCollapse collapse = FieldCollapse.of(i -> i.field("project_id"));
        builder.collapse(collapse);
        builder.trackTotalHits(i -> i.enabled(true));
        SearchResponse<Patent> response = null;
        try {
            response = client.search(builder.build(), Patent.class);
        } catch (Exception e) {
            throw new XiaoShiException(ExceptionEnum.BUSINESS_ERROR, "ES检索失败");
        }
        List<Hit<Patent>> hits = response.hits().hits();
        if (hits != null && hits.size() > 0) {
            hits.forEach(item -> {
                        Patent patent = item.source();
                        projectIds.add(patent.getProjectId());
                    }
            );
        }
        return projectIds;

    }


    public PatentNoWithIdVO addPatentToProject(PatentNoWithIdVO patentWithIdVO, Integer projectId) {

        try {


            String patentId = patentWithIdVO.getId();
            if (patentId == null) {
                PatentWithIdVO patentWithIdVO1 = esService.getIdByPatentNo(patentWithIdVO.getPatentNo());
                patentId = patentWithIdVO1.getId();
            }
            Boolean ifInproject = esService.searchPatent(patentId, projectId);
            if (!ifInproject) {
                Patent patentChild = new Patent();
                PatentJoin patentJoin = new PatentJoin();
                patentJoin.setParent(patentId);
                patentJoin.setName("project");
                patentChild.setPatentJoin(patentJoin);
                patentChild.setProjectId(projectId);
                esService.addChildPatent(patentChild, patentId);

            }
            return patentWithIdVO;
        } catch (Exception e) {
            throw new XiaoShiException(ExceptionEnum.BUSINESS_ERROR, e.getMessage());
        }

    }

    /**
     * lrj
     * 为导入专利向量建立的方法，不具有普遍性，其他功能勿用
     *
     * @param queryRequest
     * @return
     * @throws Exception
     */
    public PatentDTO getPatentforVector(QueryRequest queryRequest) throws Exception {
        PatentDTO dto = new PatentDTO();
        Integer projectId = queryRequest.getProjectId();
        Long current = queryRequest.getCurrent();
        Long size = queryRequest.getSize();

        SearchRequest.Builder builder = new SearchRequest.Builder();
        //设置查询索引
        builder.index("patent");
        List<String> reSources = new ArrayList<>();
        reSources.add("abstract_str");
        reSources.add("abstract_vector");
        reSources.add("patent_no");
        builder.source(sourceOptionsBuilder -> sourceOptionsBuilder
                .filter(fieldSourceBuilder -> fieldSourceBuilder
                        .includes(reSources)));
        //解除最大条数限制
        builder.trackTotalHits(i -> i.enabled(true));
        Query query = null;
        if (projectId != null) {
            query = QueryBuilders.hasChild(child -> child.type("project")
                    .query(org.springframework.data.elasticsearch.client.elc.QueryBuilders.matchQueryAsQuery("project_id", projectId.toString(), null, null)));
        } else {
            query = QueryBuilders.exists(i -> i.field("patent_no"));
        }
        SearchResponse<Patent> response = null;
        builder.query(query);

        if (current > 0 && size > 0) {
            builder.from((current.intValue() - 1) * size.intValue()).size(size.intValue());
        }
        SortOptions sortOptions = SortOptions.of(i -> i.field(j -> j.field("patent_no.keyword").order(SortOrder.Desc).missing(-1)));
        builder.sort(sortOptions);
        try {
            response = client.search(builder.build(), Patent.class);
        } catch (Exception e) {
//            e.printStackTrace();
            throw new XiaoShiException(ExceptionEnum.BUSINESS_ERROR, "检索错误，请检查检索式");
        }
        List<PatentColumnDTO> list = new ArrayList<>();
        List<Hit<Patent>> hits = response.hits().hits();
        long total = 0L;
        total = response.hits().total().value();
        for (Hit<Patent> hit : hits) {
            String id = hit.id();
            Patent esMess = hit.source();
            PatentColumnDTO columnDTO = new PatentColumnDTO();
            BeanUtils.copyProperties(esMess, columnDTO);
            columnDTO.setPatentId(id);
            list.add(columnDTO);
        }
        dto.setTotal(total);
        dto.setPatents(list);
        dto.setPageNum(current);
        dto.setPageSize(size);
        return dto;
    }

    public Integer removeByNo(String no) {
        Query query = QueryBuilders.term(t -> t.field("patent_no.keyword").value(no));

        DeleteByQueryRequest request = DeleteByQueryRequest.of(i -> i.index("patent").refresh(true).query(query)
                .refresh(true));
        try {
            client.deleteByQuery(request);
            return 1;
        } catch (IOException e) {
            throw new XiaoShiException(ExceptionEnum.BUSINESS_ERROR, "删除失败");
        }
    }


    //获取合并申请人
    public List<PatentMergePerson> getMergeApp2(Integer projectId, String id) throws IOException {
        SearchRequest.Builder builder = new SearchRequest.Builder();
        //设置查询索引
        builder.index("patent");
        Query q1 = QueryBuilders.term(i -> i.field("merge_applicat.project_id").value(projectId));
        Query exist1 = QueryBuilders.exists(i -> i.field("merge_applicat"));
        Query bool = QueryBuilders.bool(i -> i.must(q1, exist1));
        Query nested = QueryBuilders.nested(i -> i.path("merge_applicat").query(bool));
        Query ids = QueryBuilders.ids(i -> i.values(Arrays.asList(id)));
        Query query = QueryBuilders.hasParent(i -> i.parentType("patent").query(ids));
        Query q = QueryBuilders.bool(i -> i.must(nested, query));
        builder.query(q);
        SearchResponse<Patent> response = null;
        try {
            response = client.search(builder.build(), Patent.class);
        } catch (IOException e) {
            throw new XiaoShiException(ExceptionEnum.BUSINESS_ERROR, "ES检索失败");
        }
        List<Hit<Patent>> hits = response.hits().hits();
        List<PatentMergePerson> list = new ArrayList<>();
        for (Hit<Patent> hit : hits) {
            Patent patent = hit.source();
            if (!CollectionUtils.isEmpty(patent.getMergeApplicant())) {
                list.addAll(patent.getMergeApplicant());
            }
        }

        return list;
    }

    //获取合并权利人
    public List<PatentMergePerson> getMergeRight2(Integer projectId, String id) throws IOException {
        SearchRequest.Builder builder = new SearchRequest.Builder();
        //设置查询索引
        builder.index("patent");
        Query q1 = QueryBuilders.term(i -> i.field("merge_right_holder.project_id").value(projectId));
        Query exist1 = QueryBuilders.exists(i -> i.field("merge_right_holder"));
        Query bool = QueryBuilders.bool(i -> i.must(q1, exist1));
        Query nested = QueryBuilders.nested(i -> i.path("merge_right_holder").query(bool));
        Query ids = QueryBuilders.ids(i -> i.values(Arrays.asList(id)));
        Query query = QueryBuilders.hasParent(i -> i.parentType("patent").query(ids));
        Query q = QueryBuilders.bool(i -> i.must(nested, query));
        builder.query(q);
        SearchResponse<Patent> response = null;
        try {
            response = client.search(builder.build(), Patent.class);
        } catch (IOException e) {
            throw new XiaoShiException(ExceptionEnum.BUSINESS_ERROR, "ES检索失败");
        }
        List<Hit<Patent>> hits = response.hits().hits();
        List<PatentMergePerson> list = new ArrayList<>();
        for (Hit<Patent> hit : hits) {
            Patent patent = hit.source();
            if (!CollectionUtils.isEmpty(patent.getMergeRightHolder())) {
                list.addAll(patent.getMergeRightHolder());
            }
        }

        return list;
    }

    //获取合并发明人
    public List<PatentMergePerson> getMergeInventor2(Integer projectId, String id) throws IOException {
        SearchRequest.Builder builder = new SearchRequest.Builder();
        //设置查询索引
        builder.index("patent");
        Query q1 = QueryBuilders.term(i -> i.field("merge_inventor.project_id").value(projectId));
        Query exist1 = QueryBuilders.exists(i -> i.field("merge_inventor"));
        Query bool = QueryBuilders.bool(i -> i.must(q1, exist1));
        Query nested = QueryBuilders.nested(i -> i.path("merge_inventor").query(bool));
        Query ids = QueryBuilders.ids(i -> i.values(Arrays.asList(id)));
        Query query = QueryBuilders.hasParent(i -> i.parentType("patent").query(ids));
        Query q = QueryBuilders.bool(i -> i.must(nested, query));
        builder.query(q);
        SearchResponse<Patent> response = null;
        try {
            response = client.search(builder.build(), Patent.class);
        } catch (IOException e) {
            throw new XiaoShiException(ExceptionEnum.BUSINESS_ERROR, "ES检索失败");
        }
        List<Hit<Patent>> hits = response.hits().hits();
        List<PatentMergePerson> list = new ArrayList<>();
        for (Hit<Patent> hit : hits) {
            Patent patent = hit.source();
            if (!CollectionUtils.isEmpty(patent.getMergeInventor())) {
                list.addAll(patent.getMergeInventor());
            }
        }
        return list;
    }


}