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.model.cronModel.Personnel;
import cn.cslg.pas.common.model.cronModel.PersonnelVO;
import cn.cslg.pas.common.model.cronModel.Records;
import cn.cslg.pas.common.model.cronModel.SystemFile;
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.CacheUtils;
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.domain.business.PatentClaim;
import cn.cslg.pas.domain.business.Product;
import cn.cslg.pas.domain.business.ProductCategory;
import cn.cslg.pas.domain.es.*;
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.SortOrder;
import co.elastic.clients.elasticsearch._types.query_dsl.Query;
import co.elastic.clients.elasticsearch._types.query_dsl.QueryBuilders;
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.Hit;
import co.elastic.clients.elasticsearch.core.search.SourceConfig;
import co.elastic.clients.elasticsearch.core.search.SourceConfigBuilders;
import co.elastic.clients.elasticsearch.transform.Source;
import com.alibaba.druid.sql.visitor.functions.If;
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.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.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;

    /**
     * 根据专利号查询专利详情
     *
     * @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 q = QueryBuilders.term(i -> i.field("patent_no.keyword").value(vo.getPatentNo()));
        Query query = QueryBuilders.bool(i -> i.must(q));
        builder.query(query);
        SearchResponse<Patent> response = client.search(builder.build(), Patent.class);
        List<Hit<Patent>> hits = response.hits().hits();
        for (Hit<Patent> hit : hits) {
            Patent esMess = hit.source();
            BeanUtils.copyProperties(esMess, dto);
            //格式化权利要求
            List<Text> claims = dto.getClaim();
            if (claims != null && claims.size() > 0) {
                claims.forEach(item -> {
                    item.setTextContent(PatentRightUtils.getFormatClaim(item.getTextContent(), item.getLanguage()));
                });
            }
            dto.setRightHolderAddr(esMess.getRightHolderAddr());
            dto.setApplicantAddr(esMess.getApplicantAddr());
            if (!CollectionUtils.isEmpty(esMess.getApplicant())) {
                dto.setApplicant(this.loadName(esMess.getApplicant()));
            }
            if (!CollectionUtils.isEmpty(esMess.getRightHolder())) {
                dto.setRightHolder(this.loadName(esMess.getRightHolder()));
            }
            if (!CollectionUtils.isEmpty(esMess.getInventor())) {
                dto.setInventor(this.loadName(esMess.getInventor()));
            }
        }
        dto.setPictureGuid(FormatUtil.getPictureFormat(dto.getAppNo()));
        List<LegalEvent> legalEvents = this.getLegalEvents(dto.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 = client.search(builder.build(), LegalEvent.class);
            List<Hit<LegalEvent>> hits = response.hits().hits();
            for (Hit<LegalEvent> hit : hits) {
                LegalEvent event = hit.source();
                events.add(event);
            }
        }
        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).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 = client.search(builder.build(), Patent.class);
        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 = client.search(builder.build(), Patent.class);
        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 = client.search(builder.build(), Patent.class);
        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);
            list = JSONArray.parseArray(jsonObject.get("data").toString(), 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 = client.search(builder.build(), PatentFamilyMessage.class);
        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 = QueryBuilders.term(t -> t.field("app_no.keyword").value(vo.getAppNo()));
        //公开号
        Query 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;
        if (StringUtils.isNotEmpty(patentNo)) {
            String str = "*";
            String s = str.concat(patentNo).concat("*");
            Query query = QueryBuilders.wildcard(i -> i.field("patent_no.keyword").value(s));
            bool = QueryBuilders.bool(i -> i.should(q1, q2).must(query));
        } else {
            bool = QueryBuilders.bool(i -> i.should(q1, q2));
        }
        builder.query(bool);
        //分页
        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();
        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 = client.search(builder.build(), Patent.class);
        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<>();
        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 = client.search(builder.build(), Patent.class);
        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;
    }


    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");
        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();
        SearchRequest.Builder builder = new SearchRequest.Builder();
        //设置查询索引
        builder.index("patent");
        Query q = this.getQuery(queryRequest);
        //4. 返回数据
        builder.query(q);
        //排序
        List<OrderDTO> dtoList = queryRequest.getOrderDTOList();
        if (!CollectionUtils.isEmpty(dtoList)) {
            String json = CommonService.readJsonFile("patent.json");
            List<EsConfigVO> esConfigVOS = JSON.parseArray(json, EsConfigVO.class);
            for (OrderDTO orderDTO : dtoList) {
                EsConfigVO configVO = esConfigVOS.stream().filter(item -> item.getField().equals(orderDTO.getOrderBy())).findFirst().orElse(null);
                if (configVO != null) {
                    if (orderDTO.getOrderType().equals(IfConstant.NO)) {
                        builder.sort(sortOptionsBuilder -> sortOptionsBuilder
                                .field(fieldSortBuilder -> fieldSortBuilder
                                        .field(configVO.getEsField()).order(SortOrder.Asc)));
                    } else {
                        builder.sort(sortOptionsBuilder -> sortOptionsBuilder
                                .field(fieldSortBuilder -> fieldSortBuilder
                                        .field(configVO.getEsField()).order(SortOrder.Desc)));
                    }
                }
            }
        } else {
            builder.sort(sortOptionsBuilder -> sortOptionsBuilder
                    .field(fieldSortBuilder -> fieldSortBuilder
                            .field("patent_no.keyword").order(SortOrder.Desc)));
        }
        //分页
        if (current > 0 && size > 0) {
            builder.from(current.intValue() - 1).size(size.intValue());
        }
        SearchResponse<Patent> response = client.search(builder.build(), Patent.class);
        List<Hit<Patent>> hits = response.hits().hits();
        for (Hit<Patent> hit : hits) {
            PatentPageMessageVO patentPageMessageVO = new PatentPageMessageVO();
            patentPageMessageVO.setPatentNo(hit.source().getPatentNo());
            patentPageMessageVOS.add(patentPageMessageVO);
        }
        Records records = new Records();
        records.setTotal(response.hits().total().value());
        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 = client.search(builder.build(), Patent.class);
        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 = client.search(builder.build(), Patent.class);
        return response.hits().total().value();
    }


    public Query getQuery(QueryRequest queryRequest) throws Exception {
        String searchCondition = "";
        Integer projectId = queryRequest.getProjectId();
        //判断表达式
        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 (projectId != null) {
            if (searchCondition != null && !"".equals(searchCondition.trim())) {
                searchCondition = "projectId = " + projectId + " AND " + searchCondition;
            } else {
                searchCondition = "projectId = " + projectId;
            }
        }

        //1. 解析检索条件
        treeNode tree = expressManager.getInstance().Parse(searchCondition, false);
        //格式化检索式
        //3. 从es中检索数据
        Query q = formatQueryService.EsQueryToQuery((operateNode) tree, "patent");

        return q;
    }

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


    /**
     * 根据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 = client.search(builder.build(), Patent.class);
        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)
        );
    }

}