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

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

import cn.cslg.pas.common.core.base.IfConstant;
import cn.cslg.pas.common.dto.GetUnselectedDTO;
import cn.cslg.pas.common.dto.PatentColumnDTO;
import cn.cslg.pas.common.dto.PatentDTO;
//import cn.cslg.pas.common.dto.business.EsPatentFamilyDTO;
import cn.cslg.pas.common.dto.PatentStarListDTO;
import cn.cslg.pas.common.dto.business.ContentDetailDTO;
import cn.cslg.pas.common.dto.business.EsPatentFamilyDTO;
import cn.cslg.pas.common.dto.business.SelectClaimDTO;
import cn.cslg.pas.common.dto.es.EsCustomFieldValueDTO;
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.parseQueryToTree.expressManager;
import cn.cslg.pas.common.utils.parseQueryToTree.operateNode;
import cn.cslg.pas.common.utils.parseQueryToTree.treeNode;
import cn.cslg.pas.common.vo.*;
import cn.cslg.pas.common.vo.es.PatentFamilyMessageWithId;
import cn.cslg.pas.domain.es.*;
import cn.cslg.pas.exception.XiaoShiException;
import cn.cslg.pas.service.business.CommonService;
import cn.cslg.pas.service.common.PatentStarApiService;
import cn.cslg.pas.service.query.FormatQueryService;
import co.elastic.clients.elasticsearch.ElasticsearchClient;
import co.elastic.clients.elasticsearch._types.*;
import co.elastic.clients.elasticsearch._types.aggregations.*;
import co.elastic.clients.elasticsearch._types.query_dsl.*;
import co.elastic.clients.elasticsearch.core.*;
import co.elastic.clients.elasticsearch.core.search.Hit;
import co.elastic.clients.json.JsonData;
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.elasticsearch.client.RequestOptions;
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.SimpleDateFormat;
import java.util.*;


@Service
@RequiredArgsConstructor(onConstructor_ = {@Lazy})
public class EsService {
    public final List<String> dateList = Arrays.asList("AD", "PD", "GD", "EXD", "PAD", "PED", "PPD", "EPD");
    private final ElasticsearchClient client;

    @Autowired
    private FormatQueryService formatQueryService;
    @Autowired
    private PatentStarApiService patentStarApiService;
    @Autowired
    private EsPatentService esPatentService;
    @Lazy
    @Autowired
    private EsCountService esCountService;


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

    /**
     * @param patent
     * @throws Exception
     */
    public String addChildPatent(Patent patent, String id) throws Exception {
        IndexResponse indexResponse = client.index(i -> i
                .index("patent")
                .routing(id)
                //传入user对象
                .document(patent).refresh(Refresh.True).waitForActiveShards(WaitForActiveShards.of(t -> t.count(1)))
        );
        return indexResponse.id();
    }


    /**
     * 根据专利号获取专利id
     *
     * @param patentNo
     * @return
     * @throws Exception
     */
    public PatentWithIdVO getIdByPatentNo(String patentNo) throws Exception {
        SearchRequest.Builder builder = new SearchRequest.Builder();
        //设置查询索引
        builder.index("patent");
        PatentWithIdVO patentWithIdVO = null;
        String id = null;
        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));
        builder.query(query);
        SearchResponse<Patent> response = client.search(builder.build(), Patent.class);
        List<Hit<Patent>> hits = response.hits().hits();
        if (hits != null && hits.size() > 0) {
            id = hits.get(0).id();
            Patent patent = hits.get(0).source();
            patentWithIdVO = new PatentWithIdVO();
            patentWithIdVO.setPatent(patent);
            patentWithIdVO.setId(id);
        }
        return patentWithIdVO;
    }


    /**
     * Es检索
     *
     * @param queryRequest 检索条件
     * @return
     */
    public PatentDTO esSearch(QueryRequest queryRequest) throws Exception {
        PatentDTO dto = new PatentDTO();
        Integer taskId = queryRequest.getTaskId();
        String searchCondition = "";
        Integer projectId = queryRequest.getProjectId();
        Integer productId = queryRequest.getProductId();
        String productFrom = queryRequest.getFrom();
        Long current = queryRequest.getCurrent();
        Long size = queryRequest.getSize();
        String groupField = queryRequest.getGroupField();
        //判断表达式
        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();
        }
        List<EsCustomFieldValueDTO> customFields = queryRequest.getCustomFields();
        if (!CollectionUtils.isEmpty(customFields)) {
            searchCondition = this.parseCustomField(customFields,projectId,taskId);
        }
        if (taskId != null) {
            if (searchCondition != null && !"".equals(searchCondition.trim())) {
                searchCondition = "taskId = " + taskId + " AND " + searchCondition;
            } else {
                searchCondition = "taskId = " + taskId;
            }
        } else {
            if (StringUtils.isNotEmpty(productFrom)) {
                if (productId != null) {
                    if (searchCondition != null && !"".equals(searchCondition.trim())) {
                        searchCondition = "productId = " + productId + " AND " + searchCondition;
                    } else {
                        searchCondition = "productId = " + productId;
                    }
                }
            } 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",projectId);
        //判断同族分组
        String str = "";
        if (StringUtils.isNotEmpty(groupField)) {
            switch (groupField) {
                case "simpleFamilyId":
                    str = "simple_family_id";
                    break;
                case "inpadocFamilyId":
                    str = "inpadoc_family_id";
                    break;
                case "patsnapFamilyId":
                    str = "patsnap_family_id";
                    break;
            }
        }
        String esField = str;
        if (StringUtils.isNotEmpty(esField)) {
            List<SortOptions> options = new ArrayList<>();
            SortOptions appDate = SortOptions.of(i -> i.field(j -> j.field("app_date").order(SortOrder.Asc)));
            options.add(appDate);
            Aggregation hits = AggregationBuilders.topHits(i -> i.size(1).sort(options));
            Aggregation aggregation = new Aggregation.Builder().terms(new TermsAggregation.Builder()
                    .field(esField).build())
                    .aggregations(new HashMap() {{
                        put("hitAgg", hits);
                    }}).build();
            Aggregation filterAgg = new Aggregation.Builder().filter(i -> i.bool(j -> j.must(q)))
                    .aggregations(new HashMap() {{
                        put("filterAgg", aggregation);
                    }}).build();
            builder.aggregations("Agg", filterAgg);
        } else {
            //4. 返回数据
            builder.query(q);
        }

        //排序
        List<SortOptions> optionsList = new ArrayList<>();
        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)) {
                        SortOptions sortOptions = SortOptions.of(i -> i.field(j -> j.field(configVO.getEsField()).order(SortOrder.Asc).missing(-1)));
                        optionsList.add(sortOptions);
                    } else {
                        SortOptions sortOptions = SortOptions.of(i -> i.field(j -> j.field(configVO.getEsField()).order(SortOrder.Desc).missing(-1)));
                        optionsList.add(sortOptions);
                    }
                }
            }
        } else {
            SortOptions sortOptions = SortOptions.of(i -> i.field(j -> j.field("patent_no.keyword").order(SortOrder.Desc).missing(-1)));
            optionsList.add(sortOptions);
        }
        builder.sort(optionsList);

        //分页
        if (current != null && size != null && current > 0 && size > 0) {
            builder.from((current.intValue() - 1) * size.intValue()).size(size.intValue());
        } else {
            builder.from(0).size(99999);

        }

        //解除最大条数限制
        builder.trackTotalHits(i -> i.enabled(true));
        SearchResponse<Patent> response = client.search(builder.build(), Patent.class);
        List<PatentColumnDTO> list = new ArrayList<>();
        long total = 0L;
        if (StringUtils.isNotEmpty(esField)) {
            Aggregate agg = response.aggregations().get("Agg");
            Aggregate filtersAgg = agg.filter().aggregations().get("filterAgg");
            List<StringTermsBucket> termsBuckets = filtersAgg.sterms().buckets().array();
            for (StringTermsBucket termsBucket : termsBuckets) {
                Aggregate hitAgg = termsBucket.aggregations().get("hitAgg");
                total = hitAgg.topHits().hits().total().value();
                List<Hit<JsonData>> hits = hitAgg.topHits().hits().hits();
                hits.forEach(hit -> {
                    String id = hit.id();
                    JsonData data = hit.source();
                    Patent patent1 = JSONObject.parseObject(String.valueOf(data), Patent.class);
                    PatentColumnDTO columnDTO = new PatentColumnDTO();
                    BeanUtils.copyProperties(patent1, columnDTO);
                    if (projectId != null) {
                        try {
                            columnDTO.setMergeApplicant(esPatentService.getMergeApp(projectId, id));
                        } catch (IOException e) {
                            columnDTO.setMergeApplicant(new ArrayList<>());
                        }
                        try {
                            columnDTO.setMergeRightHolder(esPatentService.getMergeRight(projectId, id));
                        } catch (IOException e) {
                            columnDTO.setMergeRightHolder(new ArrayList<>());
                        }
                        try {
                            columnDTO.setMergeInventor(esPatentService.getMergeInventor(projectId, id));
                        } catch (IOException e) {
                            columnDTO.setMergeInventor(new ArrayList<>());
                        }
                    }
                    if (ObjectUtils.isNotEmpty(patent1.getApplicantAddr())) {
                        PersonAddress applicantAddr = patent1.getApplicantAddr();
                        columnDTO.setAppAddress(applicantAddr.getAddress());
                        columnDTO.setApplicantCountry(applicantAddr.getCountry());
                        columnDTO.setAppProvince(applicantAddr.getProvince());
                        columnDTO.setAppCity(applicantAddr.getCity());
                        columnDTO.setAppDistrict(applicantAddr.getDistrict());
                    }
                    if (ObjectUtils.isNotEmpty(patent1.getRightHolderAddr())) {
                        PersonAddress rightAddr = patent1.getRightHolderAddr();
                        columnDTO.setRightAddress(rightAddr.getAddress());
                        columnDTO.setRightCountry(rightAddr.getCountry());
                        columnDTO.setRightProvince(rightAddr.getProvince());
                        columnDTO.setRightCity(rightAddr.getCity());
                        columnDTO.setRightDistrict(rightAddr.getDistrict());
                    }
                    columnDTO.setApplicant(esPatentService.loadName(patent1.getApplicant()));
                    columnDTO.setRightHolder(esPatentService.loadName(patent1.getRightHolder()));
                    columnDTO.setInventor(esPatentService.loadName(patent1.getInventor()));
                    list.add(columnDTO);
                });
            }
        } else {
            List<Hit<Patent>> hits = response.hits().hits();
            total = response.hits().total().value();
            for (Hit<Patent> hit : hits) {
                String id = hit.id();
                Patent esMess = hit.source();
                PatentColumnDTO columnDTO = new PatentColumnDTO();
//            columnDTO.setPatentNo(esMess.getPatentNo());
                BeanUtils.copyProperties(esMess, columnDTO);
                if (projectId != null) {
                    try {
                        columnDTO.setMergeApplicant(esPatentService.getMergeApp(projectId, id));
                    } catch (IOException e) {
                        columnDTO.setMergeApplicant(new ArrayList<>());
                    }
                    try {
                        columnDTO.setMergeRightHolder(esPatentService.getMergeRight(projectId, id));
                    } catch (IOException e) {
                        columnDTO.setMergeRightHolder(new ArrayList<>());
                    }
                    try {
                        columnDTO.setMergeInventor(esPatentService.getMergeInventor(projectId, id));
                    } catch (IOException e) {
                        columnDTO.setMergeInventor(new ArrayList<>());
                    }
                }
                if (ObjectUtils.isNotEmpty(esMess.getApplicantAddr())) {
                    PersonAddress applicantAddr = esMess.getApplicantAddr();
                    columnDTO.setAppAddress(applicantAddr.getAddress());
                    columnDTO.setApplicantCountry(applicantAddr.getCountry());
                    columnDTO.setAppProvince(applicantAddr.getProvince());
                    columnDTO.setAppCity(applicantAddr.getCity());
                    columnDTO.setAppDistrict(applicantAddr.getDistrict());
                }
                if (ObjectUtils.isNotEmpty(esMess.getRightHolderAddr())) {
                    PersonAddress rightAddr = esMess.getRightHolderAddr();
                    columnDTO.setRightAddress(rightAddr.getAddress());
                    columnDTO.setRightCountry(rightAddr.getCountry());
                    columnDTO.setRightProvince(rightAddr.getProvince());
                    columnDTO.setRightCity(rightAddr.getCity());
                    columnDTO.setRightDistrict(rightAddr.getDistrict());
                }
                columnDTO.setApplicant(esPatentService.loadName(esMess.getApplicant()));
                columnDTO.setRightHolder(esPatentService.loadName(esMess.getRightHolder()));
                columnDTO.setInventor(esPatentService.loadName(esMess.getInventor()));
                list.add(columnDTO);

            }
        }
        this.loadCoulumnDTO(list);
        dto.setTotal(total);
        dto.setPatents(list);
        dto.setPageNum(current);
        dto.setPageSize(size);
        return dto;
    }

    /**
     * 解析自定义栏位和值
     *
     * @param customFields
     * @return
     */
    public String parseCustomField(List<EsCustomFieldValueDTO> customFields, Integer projectId, Integer taskId) throws Exception {
        int m = 1;
        int n = 0;
        StringBuilder builder = new StringBuilder();
        long start = System.currentTimeMillis();
        if (customFields.size() > m) {
            for (int i = 0; i < customFields.size(); i++) {
                EsCustomFieldValueDTO customField = customFields.get(i);
                if (i != n) {
                    builder.append(" ").append("and").append(" ").append("(");
                    this.appendStr(customField, builder, m, customField.getIfHaveChild(), projectId, taskId);
                } else {
                    builder.append("(");
                    this.appendStr(customField, builder, m, customField.getIfHaveChild(), projectId, taskId);
                }
            }
        } else {
            for (int i = 0; i < customFields.size(); i++) {
                EsCustomFieldValueDTO customField = customFields.get(i);
                if (i != n) {
                    builder.append(" ").append("and").append(" ");
                    this.appendStr(customField, builder, m, customField.getIfHaveChild(), projectId, taskId);
                } else {
                    builder.append("(");
                    this.appendStr(customField, builder, m, customField.getIfHaveChild(), projectId, taskId);
                }
            }
        }

        long end = System.currentTimeMillis();
        System.out.println("耗时" + (end - start));
        return builder.toString();
    }

    public void appendStr(EsCustomFieldValueDTO customField, StringBuilder builder, int m, boolean ifHaveChild,
                          Integer projectId, Integer taskId) throws Exception {
        builder.append("field").append("=").append(customField.getFieldId());
        List<String> values = customField.getFieldValue();
        if (values.contains("未选择")) {
            values.removeIf(value -> value.equals("未选择"));
            values.add("未选择");
        }
        if (!CollectionUtils.isEmpty(values)) {
            builder.append(" ").append("and").append(" ");
            if (ifHaveChild) {
                builder.append("statsValue").append("=");
            } else {
                builder.append("fieldValue").append("=");
            }

            if (values.size() > m) {
                builder.append("(");
                for (int j = 0; j < values.size(); j++) {
                    String s = values.get(j);
                    if (j != values.size() - m) {
                        builder.append(s).append(" ").append("or").append(" ");
                    } else {
                        if (s.equals("未选择")) {
                            GetUnselectedDTO unselectedDTO = esCountService.getUnselectedCustomNum(projectId, taskId);
                            List<String> childIds = unselectedDTO.getBeinglessChildIds();
                            List<String> nos = this.getPatentNos(childIds);
                            String noCondition = this.appendPatentNo(nos);
                            builder.append(s).append(")").append(" ").append("or")
                                    .append(" ").append("(").append(noCondition).append(")").append(")");
                        } else {
                            builder.append(s).append(")").append(")");
                        }
                    }
                }
            } else {
                for (String value : values) {
                    if (value.equals("未选择")) {
                        GetUnselectedDTO unselectedDTO = esCountService.getUnselectedCustomNum(projectId, taskId);
                        List<String> childIds = unselectedDTO.getBeinglessChildIds();
                        List<String> nos = this.getPatentNos(childIds);
                        String noCondition = this.appendPatentNo(nos);
                        builder.append(value).append(" ").append("or").append(" ").append(noCondition).append(")");
                    } else {
                        builder.append(value).append(")");
                    }
                }
            }
        } else {
            builder.append(")");
        }
    }

    /**
     * @param key
     * @param page
     * @param limit
     * @return
     */
    public List<Patent> search(String key, Integer page, Integer limit) throws IOException {
        SearchRequest.Builder builder = new SearchRequest.Builder();
        //设置查询索引
        builder.index("patent");
        //组装查询条件
        BoolQuery.Builder boolQuery = new BoolQuery.Builder();
        boolQuery.should(q -> q.match(v -> v
                .query(key)
                //字段名
                .field("patent_no")
        ));

        //多字段匹配
//        boolQuery.should(q -> q.matchPhrasePrefix(m -> m.query(key).field("content")));

        builder.query(q -> q.bool(boolQuery.build()));
        //分页
        if (page != null && limit != null) {
            builder.from(page).size(limit);
        }

        //排序
//        builder.sort(sortOptionsBuilder -> sortOptionsBuilder
//                .field(fieldSortBuilder -> fieldSortBuilder
//                        .field("createTime").order(SortOrder.Desc)));
        SearchResponse<Patent> response = client.search(builder.build(), Patent.class);
        List<Patent> list = new ArrayList<>();
        List<Hit<Patent>> hits = response.hits().hits();
        for (Hit<Patent> hit : hits) {
            Patent esMess = hit.source();
            list.add(esMess);
        }

        return list;
    }

    //更新patent
    public Integer updatePatent(Patent patent, String id) {
        UpdateRequest<Patent, Patent> req;

        req = UpdateRequest.of(
                b -> b.index("patent").id(id)
                        .doc(patent)
        );

        try {
            client.update(req, Patent.class);
            return 1;
        } catch (IOException e) {
            return -1;
        }
    }

    //更新patent
    public Integer updatePatentShouldWait(Patent patent, String id) {
        UpdateRequest<Patent, Patent> req;

        req = UpdateRequest.of(
                b -> b.index("patent").id(id)
                        .doc(patent).refresh(Refresh.True).waitForActiveShards(WaitForActiveShards.of(i -> i.count(1)))
        );

        try {
            client.update(req, Patent.class);
            return 1;
        } catch (IOException e) {
            return -1;
        }
    }

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

    /*POST /patent/_update_by_query
    {
        "script": {
        "source": "ctx._source.project_id = 1",
                "lang": "painless"
    },
        "query": {
        "term": {
            "_id": "yYVNzowBmzIo81_44OnV"
        }
    }
    }*/
    //更新子文档
    public Integer updateByQuery(Patent patent, String id) throws IOException {
        ESCustomField customField = patent.getESCustomField();
        String valueField = "[";
        List<String> fieldValueList = customField.getFieldValue();
        if (!CollectionUtils.isEmpty(fieldValueList)) {
            int lastSum = fieldValueList.size() - 1;
            for (int i = 0; i < fieldValueList.size(); i++) {
                String s = fieldValueList.get(i);
                if (i == lastSum) {
                    valueField = valueField + "\"" + s + "\"";
                } else {
                    valueField = valueField + "\"" + s + "\"" + ",";
                }
            }
        }
        valueField = valueField + "]";

        String valueStats = "[";
        List<String> statsValueList = customField.getStatsValue();
        if (!CollectionUtils.isEmpty(statsValueList)) {
            int lastSum = statsValueList.size() - 1;
            for (int i = 0; i < statsValueList.size(); i++) {
                String s = statsValueList.get(i);
                if (i == lastSum) {
                    valueStats = valueStats + "\"" + s + "\"";
                } else {
                    valueStats = valueStats + "\"" + s + "\"" + ",";
                }
            }
        }
        valueStats = valueStats + "]";
        SimpleDateFormat format = new SimpleDateFormat("yyyy-MM-dd");
        String s = format.format(customField.getCreateTime());
        String dateStr = "\'" + s + "\'";
        String projectId = "ctx._source.custom_field.project_id = " + customField.getProjectId() + ";";
        String field = "ctx._source.custom_field.field=" + customField.getField() + ";";
        String fieldType = "ctx._source.custom_field.field_type = " + customField.getFieldType() + ";";
        String personId = "ctx._source.custom_field.person_id = " + customField.getPersonId() + ";";
        String createTime = "ctx._source.custom_field.create_time = " + dateStr + ";";
        String fieldValue = "ctx._source.custom_field.field_value = " + valueField + ";";
        String statsValue = "ctx._source.custom_field.stats_value = " + valueStats;

        String source = projectId + field + fieldType + personId + createTime + fieldValue + statsValue;
        InlineScript inlineScript = InlineScript.of(i -> i.lang("painless").source(source));
        Script script = Script.of(i -> i.inline(inlineScript));
        Query query = QueryBuilders.term(i -> i.field("_id").value(id));
        //.waitForActiveShards(WaitForActiveShards.of(t -> t.count(1)))
        UpdateByQueryRequest request = UpdateByQueryRequest.of(i -> i.index("patent").script(script).refresh(true).query(query));
        try {
            client.updateByQuery(request);
            return 1;
        } catch (IOException e) {
            return -1;
        }
    }

    /**
     * @param key
     * @param page
     * @param limit
     * @return
     * @throws IOException
     */
    public List<Patent> searchChild(String key, Integer page, Integer limit) throws IOException {

        SearchRequest.Builder builder = new SearchRequest.Builder();
        //设置查询索引
        builder.index("patent");
        //组装查询条件
        HasChildQuery.Builder hasChildQuery = new HasChildQuery.Builder();
        hasChildQuery.type("project");
        hasChildQuery.query(q -> q.match(m -> m
                .query(key)
                //字段名
                .field("project_id")
        ));


        builder.query(q -> q.hasChild(hasChildQuery.build()));
        SearchResponse<Patent> response = client.search(builder.build(), Patent.class);
        List<Patent> list = new ArrayList<>();
        List<Hit<Patent>> hits = response.hits().hits();
        for (Hit<Patent> hit : hits) {
            Patent esMess = hit.source();
            list.add(esMess);
        }

        return list;
    }

    /**
     * 查询是否存在专利
     *
     * @param parentId
     * @param projectId
     * @return
     */
    public Boolean searchPatent(String parentId, Integer projectId) throws IOException {
        boolean flag = false;
        SearchRequest.Builder builder = new SearchRequest.Builder();
        //设置查询索引
        builder.index("patent");

        Query q1 = QueryBuilders.term(t -> t.field("project_id").value(projectId));
        Query q2 = QueryBuilders.parentId(parent -> parent.type("project").id(parentId));
        Query bool = QueryBuilders.bool(i -> i.must(q1, q2));
        builder.query(bool);
        SearchResponse<Patent> response = client.search(builder.build(), Patent.class);
        long total = response.hits().total().value();
        if (total > 0) {
            flag = true;
        }
        return flag;
    }

    /**
     * 查询是否存在专利
     *
     * @param parentId
     * @param projectId
     * @return
     */
    public Boolean ifInTask(String parentId, Integer projectId, Integer taskId) throws IOException {
        boolean flag = false;
        SearchRequest.Builder builder = new SearchRequest.Builder();
        //设置查询索引
        builder.index("patent");

        Query q1 = QueryBuilders.term(t -> t.field("import_task.project_id").value(projectId));
        Query q3 = QueryBuilders.term(t -> t.field("import_task.task_id").value(projectId));
        Query q2 = QueryBuilders.parentId(parent -> parent.type("import_task").id(parentId));
        Query bool = QueryBuilders.bool(i -> i.must(q1, q2, q3));
        builder.query(bool);
        SearchResponse<Patent> response = client.search(builder.build(), Patent.class);
        long total = response.hits().total().value();
        if (total > 0) {
            flag = true;
        }
        return flag;
    }

    /**
     * 查询同族
     *
     * @param nos
     * @param type
     * @return
     * @throws IOException
     */
    public EsPatentFamilyDTO addEsPatentFamily(Patent patent, List<String> nos, String type) throws Exception {
        EsPatentFamilyDTO esDTO = new EsPatentFamilyDTO();

        List<String> absentList = new ArrayList<>();

        PatentFamilyMessage patentFamilyMessage = null;
        String id = "";

        PatentFamilyMessageWithId patentFamilyMessageWithId = queryPatentFamily(patent, type);
        if (patentFamilyMessageWithId != null) {
            patentFamilyMessage = patentFamilyMessageWithId.getPatentFamilyMessage();
            id = patentFamilyMessageWithId.getId();
        } else {
            //遍历，根据专利号查询同族
            for (String no : nos) {
                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 p = QueryBuilders.bool(i -> i.should(q1, q2, q3));
                Query bool = QueryBuilders.bool(i -> i.must(q4, p));
                builder.query(bool);
                SearchResponse<PatentFamilyMessage> response = client.search(builder.build(), PatentFamilyMessage.class);
                long total = response.hits().total().value();
                if (total > 0) {
                    List<FamilyPatent> list = new ArrayList<>();
                    List<Hit<PatentFamilyMessage>> hits = response.hits().hits();
                    Hit<PatentFamilyMessage> hit = hits.get(0);
                    id = hit.id();
                    patentFamilyMessage = hit.source();
                    break;
                }
            }
        }

        List<String> notInNos = new ArrayList<>();
        //当查询到同族时
        if (patentFamilyMessage != null) {
            List<FamilyPatent> familyPatents = patentFamilyMessage.getPatent();
            for (String no : nos) {
                FamilyPatent familyPatent = familyPatents.stream()
                        .filter(item -> item.getAppNo() != null && item.getAppNo().equals(no) ||
                                item.getPublicNo() != null && item.getPublicNo().equals(no) ||
                                item.getGrantNo() != null && item.getGrantNo().equals(no))
                        .findFirst().orElse(null);
                if (familyPatent == null) {
                    notInNos.add(no);
                }

            }
        }
        //当未查询到同族时
        else {
            patentFamilyMessage = new PatentFamilyMessage();
            patentFamilyMessage.setFamilyType(type);
            patentFamilyMessage.setPatent(new ArrayList<>());
            notInNos.addAll(nos);

        }

        List<FamilyPatent> familyPatents = patentFamilyMessage.getPatent();
        String appNo = "";
        String publicNo = "";
        String grantNo = "";
        if (patent.getAppNo() != null) {
            appNo = patent.getAppNo();
        }
        if (patent.getPublicNo() != null) {
            publicNo = patent.getPublicNo();
        }
        if (patent.getGrantNo() != null) {
            grantNo = patent.getGrantNo();
        }
        String appNo1 = appNo;
        String publicNo1 = publicNo;
        String grantNo1 = grantNo;
        FamilyPatent patent1 = familyPatents.stream().filter(item ->
                publicNo1.equals(item.getPublicNo())
                        || publicNo1.equals(item.getGrantNo())
                        || grantNo1.equals(item.getPublicNo())
                        || grantNo1.equals(item.getGrantNo())
        ).findFirst().orElse(null);
        if (patent1 == null) {
            patent1 = new FamilyPatent();
            patent1.setGrantNo(patent.getGrantNo());
            patent1.setAppNo(patent.getAppNo());
            patent1.setPublicNo(patent.getPublicNo());
            familyPatents.add(patent1);
        } else {
            patent1.setGrantNo(patent.getGrantNo());
            patent1.setAppNo(patent.getAppNo());
            patent1.setPublicNo(patent.getPublicNo());
        }


        if (notInNos.size() > 0) {
            //所有专利号的专利详情
            List<FamilyPatent> patents = new ArrayList<>();
            notInNos.forEach(item -> {
                FamilyPatent familyPatent = new FamilyPatent();
                familyPatent.setPublicNo(item);
                patents.add(familyPatent);
            });
            patentFamilyMessage.getPatent().addAll(patents);

        }
        //当id不为null时
        if (!id.equals("")) {

            this.updatePatentFamily(patentFamilyMessage, id);

        } else {
            try {
                id = this.addPatentFamily(patentFamilyMessage);
            } catch (Exception e) {
            }


        }
        esDTO.setPatentFamilyId(id);
        esDTO.setFamilyNum(patentFamilyMessage.getPatent().size());
        return esDTO;
    }

    /**
     * 添加同族
     *
     * @param message
     * @return
     * @throws Exception
     */
    public String addPatentFamily(PatentFamilyMessage message) throws Exception {
        IndexResponse indexResponse = client.index(i -> i
                .index("patent_family")
                .document(message)
        );
        return indexResponse.id();

    }

    /**
     * 更新同族
     *
     * @param message
     * @param id
     * @return
     */
    public Integer updatePatentFamily(PatentFamilyMessage message, String id) {
        UpdateRequest<PatentFamilyMessage, PatentFamilyMessage> req;
        req = UpdateRequest.of(
                b -> b.index("patent_family")
                        .id(id)
                        .doc(message)
        );
        try {
            client.update(req, PatentFamilyMessage.class);
            return 1;
        } catch (IOException e) {
            return -1;
        }
    }

    /**
     * 更新专利事务
     *
     * @param
     * @param id
     * @return
     */
    public Integer updateLegalEvent(LegalEvent legalEvent, String id) {
        UpdateRequest<LegalEvent, LegalEvent> req;
        req = UpdateRequest.of(
                b -> b.index("legal_event")
                        .id(id)
                        .doc(legalEvent).refresh(Refresh.True).waitForActiveShards(WaitForActiveShards.of(i -> i.count(1)))
        );
        try {
            client.update(req, LegalEvent.class);
            return 1;
        } catch (IOException e) {
            return -1;
        }
    }

    /**
     * 添加法律事务
     *
     * @param
     * @return
     * @throws Exception
     */
    public String addLegalEvent(LegalEvent legalEvent) throws Exception {
        IndexResponse indexResponse = client.index(i -> i
                .index("legal_event")
                .document(legalEvent).refresh(Refresh.True).waitForActiveShards(WaitForActiveShards.of(t -> t.count(1)))
        );
        return indexResponse.id();

    }

    /**
     * 更新专利事务
     *
     * @param
     * @param id
     * @return
     */
    public Integer updateQuotePatent(PatentQuoteMessage patentQuoteMessage, String id) {
        UpdateRequest<PatentQuoteMessage, PatentQuoteMessage> req;
        req = UpdateRequest.of(
                b -> b.index("quote_patent")
                        .id(id)
                        .doc(patentQuoteMessage)
        );
        try {
            client.update(req, PatentQuoteMessage.class);
            return 1;
        } catch (IOException e) {
            return -1;
        }
    }

    /**
     * 添加法律事务
     *
     * @param
     * @return
     * @throws Exception
     */
    public String addQuotePatent(PatentQuoteMessage patentQuoteMessage) throws Exception {
        IndexResponse indexResponse = client.index(i -> i
                .index("quote_patent")
                .document(patentQuoteMessage)
        );
        return indexResponse.id();

    }


    public String addEsQuotePatent(StarPatentVO starPatentVO, List<String> nos) throws Exception {
        if (starPatentVO == null) {
            return null;
        }
        QuotePatent quotePatent = this.reQuotePatent(starPatentVO);
        PatentQuoteMessage patentQuoteMessage = null;
        //根据申请号和
        String id = "";
        //根据专利号查询是否有引用信息
        SearchRequest.Builder builder = new SearchRequest.Builder();

        //设置查询索引
        builder.index("quote_patent");
        //申请号
        Query q1 = QueryBuilders.term(t -> t.field("patent.app_no").value(starPatentVO.getApplicationNo()));
        Query bool = QueryBuilders.bool(i -> i.must(q1));
        builder.query(bool);
        SearchResponse<PatentQuoteMessage> response = client.search(builder.build(), PatentQuoteMessage.class);
        long total = response.hits().total().value();
        if (total > 0) {
            patentQuoteMessage = response.hits().hits().get(0).source();
            id = response.hits().hits().get(0).id();
        }

        List<QuotePatent> quotePatents = new ArrayList<>();
        if (patentQuoteMessage != null && patentQuoteMessage.getQuotedPatents() != null) {
            quotePatents = patentQuoteMessage.getQuotedPatents();

        }
        if (nos != null && nos.size() > 0) {
            List<Patent> patents = esPatentService.getPatentsByNo(nos, true, null, null);
            for (String patentNo : nos) {
                QuotePatent quotePatent1 = null;
                if (quotePatents.size() > 0) {
                    quotePatent1 = quotePatents.stream()
                            .filter(item -> patentNo.equals(item.getAppNo()) || patentNo.equals(item.getPublicNo()) || patentNo.equals(item.getGrantNo())).findFirst().orElse(null);
                }
                Patent patent = patents.stream().filter(item -> patentNo.equals(item.getAppNo())).findFirst().orElse(null);
                if (quotePatent1 == null) {
                    quotePatent1 = this.reQuotePatent(patent, patentNo);
                    quotePatents.add(quotePatent1);
                } else {
                    quotePatent1 = this.reQuotePatent(patent, patentNo);
                }
            }

        }


        if (patentQuoteMessage == null) {
            if (quotePatents.size() != 0) {
                patentQuoteMessage = new PatentQuoteMessage();
                patentQuoteMessage.setPatent(quotePatent);
                patentQuoteMessage.setQuotedPatents(quotePatents);
                this.addQuotePatent(patentQuoteMessage);
            }
        } else {
            patentQuoteMessage.getQuotedPatents().addAll(quotePatents);
            this.updateQuotePatent(patentQuoteMessage, id);

        }

        return "";
    }

    private QuotePatent reQuotePatent(StarPatentVO starPatentVO) {
        QuotePatent quotePatent = new QuotePatent();

        //装载申请人
        if (starPatentVO.getApplicantStr() != null && !starPatentVO.getApplicantStr().equals("")) {
            List<String> names = Arrays.asList(starPatentVO.getApplicantStr().split(";"));
            List<PatentPerson> patentPeople = new ArrayList<>();
            for (int i = 0; i < names.size(); i++) {
                PatentPerson patentPerson = new PatentPerson();
                patentPerson.setOrder(i + 1);
                patentPerson.setType("1");
                patentPerson.setName(names.get(i));
                patentPeople.add(patentPerson);
            }
            quotePatent.setApplicant(patentPeople);

        }

        //装载权利人
        if (starPatentVO.getCurrentApplicantStr() != null && !starPatentVO.getCurrentApplicantStr().equals("")) {
            List<String> names = Arrays.asList(starPatentVO.getCurrentApplicantStr().split(";"));
            List<PatentPerson> patentPeople = new ArrayList<>();
            for (int i = 0; i < names.size(); i++) {
                PatentPerson patentPerson = new PatentPerson();
                patentPerson.setOrder(0);
                patentPerson.setType("1");
                patentPerson.setName(names.get(i));
                patentPeople.add(patentPerson);
            }
            quotePatent.setRightHolder(patentPeople);
        }

        quotePatent.setAppNo(starPatentVO.getApplicationNo());
        quotePatent.setGrantNo(starPatentVO.getPublicAccreditNo());
        quotePatent.setPublicNo(starPatentVO.getPublicNo());
        return quotePatent;
    }


    private QuotePatent reQuotePatent(Patent patent, String no) {
        QuotePatent quotePatent = new QuotePatent();
        if (patent == null) {
            quotePatent.setPublicNo(no);
            return quotePatent;
        }
        //装载申请人

        quotePatent.setApplicant(patent.getApplicant());

        quotePatent.setRightHolder(patent.getRightHolder());

        quotePatent.setAppNo(patent.getAppNo());
        quotePatent.setGrantNo(patent.getGrantNo());
        quotePatent.setPublicNo(patent.getPublicNo());
        return quotePatent;
    }

    public String addEsLegalEvent(StarPatentVO starPatentVO) {
        LegalEvent legalEvent = null;
        String id = "";

        //根据专利号查询
        if (starPatentVO == null) {
            return null;
        }
        String cnLegalApiStr = patentStarApiService.getCnLegalApi(starPatentVO.getRowApplicationNo());
        if (cnLegalApiStr != null && !cnLegalApiStr.equals("")) {
            List<LegalEvent> legalEvents = new ArrayList<>();
            //根据专利号查询是否有引用信息
            SearchRequest.Builder builder = new SearchRequest.Builder();
            //设置查询索引
            builder.index("legal_event");
            //申请号
            List<Query> queries = new ArrayList<>();
            if (starPatentVO.getApplicationNo() != null) {
                Query q1 = QueryBuilders.term(t -> t.field("app_no").value(starPatentVO.getApplicationNo()));
                queries.add(q1);
            }
            if (starPatentVO.getPublicAccreditNo() != null) {
                Query q2 = QueryBuilders.term((t -> t.field("grant_no").value(starPatentVO.getPublicAccreditNo())));
                queries.add(q2);
            }
            if (starPatentVO.getPublicNo() != null) {
                Query q3 = QueryBuilders.term((t -> t.field("public_no").value(starPatentVO.getPublicNo())));
                queries.add(q3);
            }

            Query bool = QueryBuilders.bool(i -> i.should(queries));
            builder.query(bool);
            SearchResponse<LegalEvent> response = null;
            try {
                response = client.search(builder.build(), LegalEvent.class);
            } catch (IOException e) {
                e.printStackTrace();
            }
            long total = response.hits().total().value();
            if (total > 0) {
                response.hits().hits().forEach(item -> {
                    legalEvents.add(item.source());
                });
            }
               if(!cnLegalApiStr.contains("408")) {
                   List<ChinaLeagalStatus> chinaLeagalStatuses = JSON.parseArray(cnLegalApiStr, ChinaLeagalStatus.class);
                   chinaLeagalStatuses.forEach(item -> {
                       LegalEvent tem = legalEvents.stream().filter(em -> em.getEventDate() != null && em.getEventDate().compareTo(item.getLegalDate()) == 0).findFirst().orElse(null);
                       if (tem == null) {
                           LegalEvent legalEvent1 = new LegalEvent();
                           legalEvent1.setEventDate(item.getLegalDate());
                           legalEvent1.setCode(item.getLegalCode());
                           legalEvent1.setAppNo(starPatentVO.getApplicationNo());
                           legalEvent1.setGrantNo(starPatentVO.getPublicAccreditNo());
                           legalEvent1.setPublicNo(starPatentVO.getPublicNo());
                           legalEvent1.setDescription(item.getLegalStatusInfo());
                           legalEvent1.setName(item.getLegalStatus());
                           try {
                               String reId = this.addLegalEvent(legalEvent1);
                           } catch (Exception e) {
                               throw new XiaoShiException(e.getMessage());
                           }
                       }

                   });
               }

        }
        return "";
    }

    /**
     * 查询权利要求
     *
     * @param patentNo
     * @return
     */
    public SelectClaimDTO selectClaim(String patentNo) throws IOException {

        SearchRequest.Builder builder = new SearchRequest.Builder();
        //设置查询索引
        builder.index("patent");
        //原始数据
        Query q = QueryBuilders.term(t -> t.field("claim.if_origin").value(true));
        //申请号
        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));
        Query bool = QueryBuilders.bool(i -> i.must(q, query));
        builder.query(bool);
        SearchResponse<Patent> response = client.search(builder.build(), Patent.class);
        SelectClaimDTO dto = new SelectClaimDTO();
        List<Hit<Patent>> hits = response.hits().hits();
        for (Hit<Patent> hit : hits) {
            Patent esMess = hit.source();
            if (esMess != null) {
                dto.setClaimContent(esMess.getClaim());
                String claim = StringUtils.strip(JSON.toJSONString(esMess.getClaim()), "[]");
                ContentDetailDTO contentDetailDTO = JSONObject.parseObject(claim, ContentDetailDTO.class);
                if (contentDetailDTO.getIfOrigin()) {
                    dto.setClaim(contentDetailDTO.getTextContent().replaceAll("\t", ""));
                }
            }
        }
        return dto;
    }

    /**
     * 装载摘要附图
     *
     * @param patentColumnDTOS
     * @return
     */
    public List<PatentColumnDTO> loadCoulumnDTO(List<PatentColumnDTO> patentColumnDTOS) {
        patentColumnDTOS.forEach(item -> {
            item.setPictureGuid(FormatUtil.getPictureFormat(item.getAppNo()));

        });

        return patentColumnDTOS;
    }

    /**
     * 根据专利号查询出其他专利号
     *
     * @param patentNos
     * @return
     * @throws IOException
     */
    public SelectClaimDTO selectPatentNo(List<String> patentNos) throws IOException {

        SearchRequest.Builder builder = new SearchRequest.Builder();
        //设置查询索引
        builder.index("patent");
        List<Query> queryList = new ArrayList<>();
        for (String patentNo : patentNos) {
            Query q1 = QueryBuilders.term(t -> t.field("patent_no.keyword").value(patentNo));
            queryList.add(q1);
        }
        //申请号
        Query query = QueryBuilders.bool(i -> i.mustNot(queryList));
        builder.query(query);
        SearchResponse<Patent> response = client.search(builder.build(), Patent.class);
        SelectClaimDTO dto = new SelectClaimDTO();
        List<Hit<Patent>> hits = response.hits().hits();
        long value = response.hits().total().value();
        if (value > 1) {
            System.out.println("====================" + value);
        }
        return dto;
    }

    /**
     * 更新合并申请人/权利人/发明人
     *
     * @param patent
     * @param id
     * @return
     */
    public Integer updateMergePerson(Patent patent, String id) {
        UpdateRequest<Patent, Patent> req;
        req = UpdateRequest.of(
                b -> b.index("patent")
                        .id(id)
                        .doc(patent)
                        .docAsUpsert(true)
        );
        try {
            client.update(req, Patent.class);
            return 1;
        } catch (IOException e) {
            return -1;
        }
    }

    /**
     * 删除申请人/权利人/发明人合并名称
     *
     * @param patent
     * @param id
     * @return
     */
    public Integer delMergePerson(Patent patent, String id, Integer type, String name) {
        String source = "";
        if (type == 0) {
            source = "if (ctx._source.merge_applicant != null) { ctx._source.merge_applicant.removeIf(item -> item.name == params.name); } if (ctx._source.merge_right_holder  != null) { ctx._source.merge_right_holder .removeIf(item -> item.name == params.name); }";
        } else {
            source = "if (ctx._source.merge_inventor != null) { ctx._source.merge_inventor.removeIf(item -> item.name == params.name); }";
        }
        String finalSource = source;
        InlineScript inlineScript = InlineScript.of(i -> i.lang("painless").params("name", JsonData.of(name)).source(finalSource));
        Script script = Script.of(i -> i.inline(inlineScript));
        Query query = QueryBuilders.term(i -> i.field("_id").value(id));
        UpdateByQueryRequest request = UpdateByQueryRequest.of(i -> i.index("patent").script(script).query(query));
        try {
            client.updateByQuery(request);
            return 1;
        } catch (IOException e) {
            return -1;
        }
    }


    public PatentFamilyMessageWithId queryPatentFamily(Patent patent, String type) throws Exception {
        //查询该专利是否已有同族
        SearchRequest.Builder builderPatent = new SearchRequest.Builder();
        //设置查询索引
        builderPatent.index("patent_family");
        //申请号
        List<Query> queries = new ArrayList<>();
        if (patent.getAppNo() != null) {
            Query q1 = QueryBuilders.term(t -> t.field("patent.app_no").value(patent.getAppNo()));
            //公开号
            Query q2 = QueryBuilders.term(t -> t.field("patent.public_no").value(patent.getAppNo()));
            //授权号
            Query q3 = QueryBuilders.term(t -> t.field("patent.grant_no").value(patent.getAppNo()));
            //类型
            queries.add(q1);
            queries.add(q2);
            queries.add(q3);
        }
        if (patent.getPublicNo() != null) {
            Query q1 = QueryBuilders.term(t -> t.field("patent.app_no").value(patent.getPublicNo()));
            //公开号
            Query q2 = QueryBuilders.term(t -> t.field("patent.public_no").value(patent.getPublicNo()));
            //授权号
            Query q3 = QueryBuilders.term(t -> t.field("patent.grant_no").value(patent.getPublicNo()));
            queries.add(q1);
            queries.add(q2);
            queries.add(q3);
        }
        if (patent.getGrantNo() != null) {
            Query q1 = QueryBuilders.term(t -> t.field("patent.app_no").value(patent.getGrantNo()));
            //公开号
            Query q2 = QueryBuilders.term(t -> t.field("patent.public_no").value(patent.getGrantNo()));
            //授权号
            Query q3 = QueryBuilders.term(t -> t.field("patent.grant_no").value(patent.getGrantNo()));
            queries.add(q1);
            queries.add(q2);
            queries.add(q3);
        }

        Query q4 = QueryBuilders.term(t -> t.field("family_type").value(type));
        Query p = QueryBuilders.bool(i -> i.should(queries));
        Query bool = QueryBuilders.bool(i -> i.must(q4, p));
        builderPatent.query(bool);
        SearchResponse<PatentFamilyMessage> response = client.search(builderPatent.build(), PatentFamilyMessage.class);
        long total = response.hits().total().value();
        if (total > 0) {
            List<FamilyPatent> list = new ArrayList<>();
            List<Hit<PatentFamilyMessage>> hits = response.hits().hits();
            Hit<PatentFamilyMessage> hit = hits.get(0);
            String id = hit.id();
            PatentFamilyMessageWithId patentFamilyMessageWithId = new PatentFamilyMessageWithId();
            patentFamilyMessageWithId.setId(id);
            patentFamilyMessageWithId.setPatentFamilyMessage(hit.source());

            return patentFamilyMessageWithId;

        }
        return null;
    }

    public List<String> getPatentNos(List<String> ids) throws IOException {
        SearchRequest.Builder builder = new SearchRequest.Builder();
        //设置查询索引
        builder.index("patent");
        Query q = QueryBuilders.ids(i -> i.values(ids));
        builder.size(9999);
        builder.query(q);
        SearchResponse<Patent> response = client.search(builder.build(), Patent.class);
        List<Hit<Patent>> hits = response.hits().hits();
        List<String> list = new ArrayList<>();
        for (Hit<Patent> hit : hits) {
            Patent patent = hit.source();
            list.add(patent.getPatentNo());
        }
        return list;
    }

    public String appendPatentNo(List<String> nos) {
        String str = "NO = ";
        if (nos.size() > 1) {
            str = str + "(";
            for (int i = 0; i < nos.size(); i++) {
                String s = nos.get(i);
                if (i != nos.size() - 1) {
                    str = str + s + " " + "OR" + " ";
                } else {
                    str = str + s + ")";
                }
            }
        } else {
            for (String no : nos) {
                str = str + no;
            }
        }
        return str;
    }
}