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

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

import cn.cslg.pas.common.core.base.IfConstant;
import cn.cslg.pas.common.dto.es.*;
import cn.cslg.pas.common.model.request.OrderDTO;
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.EsConfigVO;
import cn.cslg.pas.common.vo.FieldValueVO;
import cn.cslg.pas.common.vo.PatentWithIdVO;
import cn.cslg.pas.common.vo.es.*;
import cn.cslg.pas.common.vo.exportProject.CustomFiledRecord;
import cn.cslg.pas.domain.business.CustomField;
import cn.cslg.pas.domain.business.CustomOption;
import cn.cslg.pas.domain.business.TreeNode;
import cn.cslg.pas.domain.es.*;
import cn.cslg.pas.exception.XiaoShiException;
import cn.cslg.pas.service.business.CommonService;
import cn.cslg.pas.service.business.CustomOptionService;
import cn.cslg.pas.service.business.TreeNodeService;
import cn.cslg.pas.service.query.FormatQueryService;
import co.elastic.clients.elasticsearch.ElasticsearchClient;
import co.elastic.clients.elasticsearch._types.SortOptions;
import co.elastic.clients.elasticsearch._types.SortOrder;
import co.elastic.clients.elasticsearch._types.aggregations.Aggregation;
import co.elastic.clients.elasticsearch._types.aggregations.AggregationBuilders;
import co.elastic.clients.elasticsearch._types.aggregations.NestedAggregation;
import co.elastic.clients.elasticsearch._types.query_dsl.Query;
import co.elastic.clients.elasticsearch._types.query_dsl.QueryBuilders;
import co.elastic.clients.elasticsearch.core.IndexResponse;
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.json.JsonData;
import com.alibaba.fastjson.JSON;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import lombok.RequiredArgsConstructor;
import lombok.Value;
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.lang.reflect.Array;
import java.text.ParseException;
import java.util.*;
import java.util.stream.Collectors;

@Service
@RequiredArgsConstructor(onConstructor_ = {@Lazy})
public class EsCustomFieldService {
    private final ElasticsearchClient client;
    private final EsService esService;
    private final TreeNodeService treeNodeService;
    private final CustomOptionService customOptionService;
    @Autowired
    private FormatQueryService formatQueryService;

    //添加自定义栏位值
    public String addCustomField(EsCustomFieldDTO esCustomFieldDTO) throws Exception {
        ESCustomField esCustomField = new ESCustomField();
        String id = "";
        //判断类型
        Integer fieldType = esCustomFieldDTO.getFieldType();
        Integer taskId = esCustomFieldDTO.getTaskId();
        Integer optionType = esCustomFieldDTO.getOptionType();
        String patentNo = esCustomFieldDTO.getPatentNo();
        String fieldId = esCustomFieldDTO.getFieldId();
        String patentId = esCustomFieldDTO.getPatentId();
        List<String> addValues = esCustomFieldDTO.getFieldValue();
        Integer projectId = esCustomFieldDTO.getProjectId();
        Date createDate = new Date();

        if (optionType.equals(1) && (addValues == null || addValues.size() == 0)) {
            throw new XiaoShiException("请填写值");
        }


        //根据专利号查询 是否专利关联过栏位
        PatentWithIdVO patentWithIdVO = this.getEsCustomField(esCustomFieldDTO);
        if (patentWithIdVO != null) {
            esCustomField = patentWithIdVO.getPatent().getESCustomField();
            id = patentWithIdVO.getId();
        } else {
            //设置栏位
            esCustomField.setField(esCustomFieldDTO.getFieldId());
            //设置专题库或报告
            esCustomField.setProjectId(esCustomFieldDTO.getProjectId());
            //设置创建时间
            esCustomField.setCreateTime(createDate);
            //设置创建人
            esCustomField.setPersonId("1");
            //设置类型
            esCustomField.setFieldType(fieldType);
            //设置任务id
            esCustomField.setTaskId(taskId);
        }
        List<String> values = esCustomField.getFieldValue();

        //设置值
        switch (fieldType) {
            case 0:

                ;
            case 1:

                ;
            case 2:              //文本类型
                if (optionType.equals(1) || optionType.equals(2)) {
                    if (addValues != null && addValues.size() == 1)
                        esCustomField.setFieldValue(addValues);
                    esCustomField.setStatsValue(addValues);
                } else if (optionType.equals(0)) {
                    esCustomField.setFieldValue(new ArrayList<>());
                    esCustomField.setStatsValue(new ArrayList<>());
                }
                break;
            case 4:     //单选
                if (optionType.equals(1) || optionType.equals(2)) {
                    if (addValues != null && addValues.size() == 1) {
                        esCustomField.setFieldValue(addValues);
                        esCustomField.setStatsValue(addValues);
                    }
                } else if (optionType.equals(0)) {
                    esCustomField.setFieldValue(new ArrayList<>());
                    esCustomField.setStatsValue(new ArrayList<>());
                }
                break;
            case 5:
                if (optionType.equals(1)) {
                    List<String> orgValue = esCustomField.getFieldValue();

                    if (orgValue == null) {
                        orgValue = new ArrayList<>();
                    }

                    for (String item : addValues) {
                        if (!orgValue.contains(item)) {
                            orgValue.add(item);
                        }
                    }
                    esCustomField.setFieldValue(orgValue);
                    esCustomField.setStatsValue(orgValue);
                } else if (optionType.equals(2)) {
                    if (addValues != null && addValues.size() > 0) {
                        esCustomField.setFieldValue(addValues);
                        esCustomField.setStatsValue(addValues);
                    } else {
                        esCustomField.setFieldValue(new ArrayList<>());
                        esCustomField.setStatsValue(new ArrayList<>());
                    }
                } else if (optionType.equals(0)) {
                    List<String> orgValue = esCustomField.getFieldValue();

                    if (orgValue == null) {
                        orgValue = new ArrayList<>();
                    }

                    for (String item : addValues) {
                        if (orgValue.contains(item)) {
                            orgValue.remove(item);
                        }
                    }
                    esCustomField.setFieldValue(orgValue);
                    esCustomField.setStatsValue(orgValue);
                }
                break;
            case 6:            //树类型

            case 7:

            case 8:

            case 9:
                if (optionType.equals(1)) {
                    //根据值获得树节点
                    List<String> reValues = FormatUtil.getDistinctList(addValues, values);
                    esCustomField.setFieldValue(reValues);
                    //根据 reValues获得 reStateValues
                    List<Integer> fieldIds = FormatUtil.StringTOIntegerList(reValues);
                    //根据树节点id查询树节点
                    LambdaQueryWrapper<TreeNode> queryWrapper = new LambdaQueryWrapper<>();
                    queryWrapper.in(TreeNode::getId, fieldIds);
                    List<TreeNode> treeNodes = treeNodeService.list(queryWrapper);
                    //遍历节点
                    List<String> reStateValues = new ArrayList<>(reValues);
                    treeNodes.forEach(item -> {
                        String path = item.getPath();
                        if (path != null && path.trim() != "") {
                            List<String> a = Arrays.asList(path.split("/"));
                            reStateValues.addAll(a);
                        }
                    });

                    List<String> disReStateValues = new ArrayList<>(new HashSet<>(reStateValues));
                    esCustomField.setStatsValue(disReStateValues);
                } else if (optionType.equals(0)) {
                    if (values != null && values.size() > 0 && addValues != null && addValues.size() > 0) {
                        values.removeAll(addValues);
                        esCustomField.setFieldValue(values);
                        if (values.size() > 0) {
                            //根据 reValues获得 reStateValues
                            List<Integer> fieldIds = FormatUtil.StringTOIntegerList(values);
                            //根据树节点id查询树节点
                            LambdaQueryWrapper<TreeNode> queryWrapper = new LambdaQueryWrapper<>();
                            queryWrapper.eq(TreeNode::getId, fieldIds);
                            List<TreeNode> treeNodes = treeNodeService.list(queryWrapper);
                            //遍历节点
                            List<String> reStateValues = new ArrayList<>(values);
                            treeNodes.forEach(item -> {
                                String path = item.getPath();
                                if (path != null && path.trim() != "") {
                                    List<String> a = Arrays.asList(path.split("/"));
                                    reStateValues.addAll(a);
                                }
                            });
                            List<String> disReStateValues = new ArrayList<>(new HashSet<>(reStateValues));
                            esCustomField.setStatsValue(disReStateValues);
                        }
                    }

                } else if (optionType.equals(2)) {
                    esCustomField.setFieldValue(addValues);
                    if (addValues == null || addValues.size() == 0) {
                        esCustomField.setStatsValue(new ArrayList<>());
                    } else {
                        //根据 reValues获得 reStateValues
                        List<Integer> fieldIds = FormatUtil.StringTOIntegerList(addValues);
                        //根据树节点id查询树节点
                        LambdaQueryWrapper<TreeNode> queryWrapper = new LambdaQueryWrapper<>();
                        queryWrapper.in(TreeNode::getId, fieldIds);
                        List<TreeNode> treeNodes = treeNodeService.list(queryWrapper);
                        //遍历节点
                        List<String> reStateValues = new ArrayList<>(addValues);
                        treeNodes.forEach(item -> {
                            String path = item.getPath();
                            if (path != null && path.trim() != "") {
                                List<String> a = Arrays.asList(path.split("/"));
                                reStateValues.addAll(a);
                            }
                        });
                        List<String> disReStateValues = new ArrayList<>(new HashSet<>(reStateValues));
                        esCustomField.setStatsValue(disReStateValues);
                    }
                }
                break;
        }
        if (!id.trim().equals("")) {
            Patent patent = patentWithIdVO.getPatent();
            patent.setESCustomField(esCustomField);
            esService.updateByQuery(patent, patentWithIdVO.getId());
            ESCustomFieldHistory esCustomFieldHistory = new ESCustomFieldHistory();
            esCustomFieldHistory.setField(fieldId);
            esCustomFieldHistory.setFieldType(fieldType);
            esCustomFieldHistory.setCreateTime(createDate);
            esCustomFieldHistory.setFieldValue(addValues);
            esCustomFieldHistory.setSavedValue(esCustomField.getFieldValue());
            esCustomFieldHistory.setHistoryType(optionType);
            esCustomFieldHistory.setTaskId(taskId);
            esCustomFieldHistory.setPersonId("1");
            esCustomFieldHistory.setProjectId(projectId);
            esCustomFieldHistory.setCustomFieldId(id);
            this.addCustomFieldHistory(esCustomFieldHistory);
        } else {
            esCustomField.setIfNew(1);
            this.addEsCustomFieldToEs(esCustomField, patentNo, patentId);
        }
        return id;
    }

    /**
     * 批量添加自定义栏位值
     *
     * @param vo
     * @return
     * @throws Exception
     */
    public List<String> batchAddCustomField(EsCustomFieldBatchVO vo) throws Exception {
        Integer startNum = vo.getStartNumber();
        Integer endNum = vo.getEndNumber();
        List<String> isAdd = vo.getIsAdd();
        List<String> isDel = vo.getIsDelete();
        List<String> ids = new ArrayList<>();
        List<EsCustomFieldDTO> fieldDTOS = vo.getEsCustomFieldDTOS();
        if (!CollectionUtils.isEmpty(isAdd) && startNum <= 1 && endNum < 1) {
            isAdd.removeAll(isDel);
            for (String patentNo : isAdd) {
                for (EsCustomFieldDTO fieldDTO : fieldDTOS) {
                    fieldDTO.setPatentNo(patentNo);
                    String field = this.addCustomField(fieldDTO);
                    ids.add(field);
                }
            }
        } else if (startNum >= 1 && endNum > 0) {
            List<String> patentNos = this.getPatentNos(vo);
            for (String patentNo : patentNos) {
                for (EsCustomFieldDTO fieldDTO : fieldDTOS) {
                    fieldDTO.setPatentNo(patentNo);
                    String field = this.addCustomField(fieldDTO);
                    ids.add(field);
                }
            }
        }
        return ids;
    }

    /**
     * 获取专利号列表
     *
     * @param vo
     * @return
     * @throws Exception
     */
    public List<String> getPatentNos(EsCustomFieldBatchVO vo) throws Exception {
        Integer taskId = vo.getTaskId();
        Integer projectId = vo.getProjectId();
        Integer startNum = vo.getStartNumber();
        Integer endNum = vo.getEndNumber();
        List<String> isAdd = new ArrayList<>();
        if (!CollectionUtils.isEmpty(vo.getIsAdd())) {
            isAdd = vo.getIsAdd();
        }
        List<String> isDel = new ArrayList<>();
        if (!CollectionUtils.isEmpty(vo.getIsDelete())) {
            isDel = vo.getIsDelete();
        }
        String searchCondition = "";
        if (StringUtils.isNotEmpty(vo.getSearchQuery())) {
            searchCondition = vo.getSearchQuery();
        }
        List<EsCustomFieldValueDTO> customFields = vo.getCustomFields();
        if (!CollectionUtils.isEmpty(customFields)) {
            searchCondition = esService.parseCustomField(customFields,projectId,taskId);
        }
        if (taskId != null) {
            if (searchCondition != null && !"".equals(searchCondition.trim())) {
                searchCondition = "taskId = " + taskId + " AND " + searchCondition;
            } else {
                searchCondition = "taskId = " + taskId;
            }
        } else {
            if (projectId != null) {
                if (searchCondition != null && !"".equals(searchCondition.trim())) {
                    searchCondition = "projectId = " + projectId + " AND " + searchCondition;
                } else {
                    searchCondition = "projectId = " + projectId;
                }
            }
        }
        SearchRequest.Builder builder = new SearchRequest.Builder();
        //设置查询索引
        builder.index("patent");
        //1. 解析检索条件
        treeNode tree = expressManager.getInstance().Parse(searchCondition, false);
        //格式化检索式
        //3. 从es中检索数据
        Query q = formatQueryService.EsQueryToQuery((operateNode) tree, "patent",null);
        builder.query(q);

        //排序
        List<SortOptions> optionsList = new ArrayList<>();
        List<OrderDTO> dtoList = vo.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);

        int number = endNum - startNum;
        if (startNum > 0 && endNum > startNum) {
            builder.from(startNum - 1).size(number);
        }

        SearchResponse<Patent> response = client.search(builder.build(), Patent.class);
        List<Hit<Patent>> hits = response.hits().hits();
        List<String> patentNos = new ArrayList<>();
        for (Hit<Patent> hit : hits) {
            Patent patent = hit.source();
            patentNos.add(patent.getPatentNo());
        }
        patentNos.addAll(isAdd);
        patentNos.removeAll(isDel);
        return patentNos.stream().collect(Collectors.toList());
    }


    //添加操作历史
    public String addCustomFieldHistory(ESCustomFieldHistory customFieldHistory) throws Exception {
        IndexResponse indexResponse = client.index(i -> i
                .index("custom_field_history")
                .document(customFieldHistory)
        );
        return indexResponse.id();

    }

    //查询自定义字段
    public PatentWithIdVO getEsCustomField(EsCustomFieldDTO esCustomFieldDTO) throws Exception {
        PatentWithIdVO patentWithIdVO = new PatentWithIdVO();
        Integer projectId = esCustomFieldDTO.getProjectId();
        Integer taskId = esCustomFieldDTO.getTaskId();
        SearchRequest.Builder builder = new SearchRequest.Builder();
        String patentNo = esCustomFieldDTO.getPatentNo();
        //设置查询索引
        builder.index("patent");

        //栏位
        Query q1 = QueryBuilders.term(t -> t.field("custom_field.project_id").value(projectId));

        Query q2 = QueryBuilders.term((t -> t.field("custom_field.field").value(esCustomFieldDTO.getFieldId())));

        Query q4 = QueryBuilders.term(t -> t.field("custom_field.field_type").value(esCustomFieldDTO.getFieldType()));

        Query parentQ1 = QueryBuilders.term(t -> t.field("app_no.keyword").value(patentNo));

        //公开号
        Query parentQ2 = QueryBuilders.term(t -> t.field("public_no.keyword").value(patentNo));

        //授权号
        Query parentQ3 = QueryBuilders.term(t -> t.field("grant_no.keyword").value(patentNo));

        Query parentQ = QueryBuilders.bool(i -> i.should(parentQ1, parentQ2, parentQ3));

        Query q3 = QueryBuilders.hasParent(t -> t.parentType("patent").query(parentQ));

        Query bool = null;

        if (taskId == null) {

            bool = QueryBuilders.bool(i -> i.must(q1, q2, q3, q4));
        } else {
            Query q5 = QueryBuilders.term((t -> t.field("custom_field.task_id").value(taskId)));
            bool = QueryBuilders.bool(i -> i.must(q1, q2, q3, q4, q5));
        }

        builder.query(bool);
        builder.sort(sortOptionsBuilder -> sortOptionsBuilder
                .field(fieldSortBuilder -> fieldSortBuilder
                        .field("custom_field.create_time").order(SortOrder.Desc)));
        SearchResponse<Patent> response = client.search(builder.build(), Patent.class);
        long total = response.hits().total().value();
        if (total > 0) {
            List<Hit<Patent>> hits = response.hits().hits();
            Hit<Patent> hit = hits.get(0);
            Patent patent = hit.source();
            patentWithIdVO.setPatent(patent);
            patentWithIdVO.setId(hit.id());
        } else {
            patentWithIdVO = null;
        }
        return patentWithIdVO;
    }

    //将自定义字段添加到专利
    public String addEsCustomFieldToEs(ESCustomField esCustomField, String patentNo, String patentId) throws Exception {
        //根据专利号查询专利
        if (patentId == null) {
            PatentWithIdVO patentWithIdVO = esService.getIdByPatentNo(patentNo);
            patentId = patentWithIdVO.getId();
        }
        Patent patentChild = new Patent();
        PatentJoin patentJoin = new PatentJoin();
        patentJoin.setParent(patentId);
        patentJoin.setName("project_customfield");
        patentChild.setPatentJoin(patentJoin);
        patentChild.setESCustomField(esCustomField);
        String id = esService.addChildPatent(patentChild, patentId);
        return id;
    }


    public String getEsCustomFieldId(FieldHistoryDTO fieldHistoryDTO) throws Exception {
        String id = "";
        List<QueryESCustomFieldVO> vos = new ArrayList<>();

        String fieldId = fieldHistoryDTO.getFieldId();
        Integer fieldType = fieldHistoryDTO.getFieldType();
        String patentNo = fieldHistoryDTO.getPatentNo();
        Query q1 = QueryBuilders.term(t -> t.field("app_no.keyword").value(patentNo));

        Query parentQ1 = QueryBuilders.term(t -> t.field("app_no.keyword").value(patentNo));
        //公开号
        Query parentQ2 = QueryBuilders.term(t -> t.field("public_no.keyword").value(patentNo));
        //授权号
        Query parentQ3 = QueryBuilders.term(t -> t.field("grant_no.keyword").value(patentNo));

        Query parentQ = QueryBuilders.bool(i -> i.should(parentQ1, parentQ2, parentQ3));
        Query q3 = QueryBuilders.hasParent(t -> t.parentType("patent").query(parentQ));


        Query q2 = QueryBuilders.term((t -> t.field("custom_field.field").value(fieldId)));
        Query q4 = QueryBuilders.term(t -> t.field("custom_field.field_type").value(fieldType));
        Query bool = QueryBuilders.bool(i -> i.must(q1, q2, q3, q4));

        SearchRequest.Builder builder = new SearchRequest.Builder();
        builder.query(bool);
        SearchResponse<Patent> response = client.search(builder.build(), Patent.class);
        long total = response.hits().total().value();
        if (total > 0) {
            id = response.hits().hits().get(0).id();

        }
        return id;
    }

    /**
     * 查询历史
     */
    public List<FieldHistoryVO> getCustomFieldHistory(FieldHistoryDTO fieldHistoryDTO) throws Exception {
        List<FieldHistoryVO> fieldHistoryVOS = new ArrayList<>();
        String customId = this.getEsCustomFieldId(fieldHistoryDTO);
        Query q1 = QueryBuilders.term(t -> t.field("custom_field_id").value(customId));
        SearchRequest.Builder builder = new SearchRequest.Builder();
        builder.query(q1);
        builder.sort(sortOptionsBuilder -> sortOptionsBuilder
                .field(fieldSortBuilder -> fieldSortBuilder
                        .field("create_time").order(SortOrder.Desc)));
        SearchResponse<ESCustomFieldHistory> response = client.search(builder.build(), ESCustomFieldHistory.class);
        long total = response.hits().total().value();
        if (total > 0) {
            List<Hit<ESCustomFieldHistory>> hits = response.hits().hits();
            hits.forEach(item -> {
                FieldHistoryVO fieldHistoryVO = new FieldHistoryVO();
                BeanUtils.copyProperties(item.source(), fieldHistoryVO);
                fieldHistoryVOS.add(fieldHistoryVO);
            });

        }
        return fieldHistoryVOS;
    }

    /**
     * 回退
     */
    public void backTo(String historyId) throws Exception {
        Hit<ESCustomFieldHistory> hit = this.getEsCustomFieldHistoryById(historyId);
        ESCustomFieldHistory esCustomFieldHistory = hit.source();
        List<String> values = esCustomFieldHistory.getSavedValue();
        String customFieldId = esCustomFieldHistory.getCustomFieldId();
        //根据id查询customField
        Patent patent = new Patent();
        String id = "";
        SearchRequest.Builder builder = new SearchRequest.Builder();
        builder.index("patent");
        Query q = QueryBuilders.ids(i -> i.values(Arrays.asList(customFieldId)));
        builder.query(q);
        SearchResponse<Patent> response = client.search(builder.build(), Patent.class);
        long total = response.hits().total().value();
        if (total > 0) {
            patent = response.hits().hits().get(0).source();
            id = response.hits().hits().get(0).id();
        }
        if (values == null || values.size() <= 0) {
            patent.getESCustomField().setFieldValue(null);
            patent.getESCustomField().setStatsValue(null);
        } else {
            List<Integer> fieldIds = FormatUtil.StringTOIntegerList(values);
            //根据树节点id查询树节点
            LambdaQueryWrapper<TreeNode> queryWrapper = new LambdaQueryWrapper<>();
            queryWrapper.eq(TreeNode::getId, fieldIds);
            List<TreeNode> treeNodes = treeNodeService.list(queryWrapper);
            //遍历节点
            List<String> reStateValues = new ArrayList<>(values);
            treeNodes.forEach(item -> {
                String path = item.getPath();
                if (path != null && path.trim() != "") {
                    List<String> a = Arrays.asList(path.split("/"));
                    reStateValues.addAll(a);
                }
            });
            List<String> disReStateValues = new ArrayList<>(new HashSet<>(reStateValues));
            patent.getESCustomField().setStatsValue(disReStateValues);
            patent.getESCustomField().setFieldValue(values);
        }
        //更新自定义栏位
        esService.updatePatent(patent, id);
        //新增历史
        ESCustomFieldHistory newEsCustomFieldHistory = new ESCustomFieldHistory();
        newEsCustomFieldHistory.setField(patent.getESCustomField().getField());
        newEsCustomFieldHistory.setFieldType(patent.getESCustomField().getFieldType());
        newEsCustomFieldHistory.setCreateTime(new Date());
        newEsCustomFieldHistory.setFieldValue(patent.getESCustomField().getFieldValue());
        newEsCustomFieldHistory.setHistoryType(3);
        newEsCustomFieldHistory.setTaskId(patent.getESCustomField().getTaskId());
        newEsCustomFieldHistory.setPersonId("1");
        newEsCustomFieldHistory.setProjectId(patent.getESCustomField().getProjectId());
        newEsCustomFieldHistory.setCustomFieldId(id);
        this.addCustomFieldHistory(esCustomFieldHistory);


    }

    //查询栏位历史
    public Hit<ESCustomFieldHistory> getEsCustomFieldHistoryById(String historyId) throws Exception {
        Hit<ESCustomFieldHistory> esCustomFieldHistoryHit = null;
        SearchRequest.Builder builder = new SearchRequest.Builder();
        builder.index("custom_field_history");
        Query q = QueryBuilders.ids(i -> i.values(Arrays.asList(historyId)));
        builder.query(q);
        SearchResponse<ESCustomFieldHistory> response = client.search(builder.build(), ESCustomFieldHistory.class);
        long total = response.hits().total().value();
        if (total > 0) {
            esCustomFieldHistoryHit = response.hits().hits().get(0);
        }
        return esCustomFieldHistoryHit;

    }

    public PatentWithIdVO getPatentLabel(AddPatentLabelDTO addPatentLabelDTO) throws Exception {
        PatentWithIdVO patentWithIdVO = new PatentWithIdVO();
        Integer projectId = addPatentLabelDTO.getProjectId();
        SearchRequest.Builder builder = new SearchRequest.Builder();
        String patentNo = addPatentLabelDTO.getPatentNo();
        //设置查询索引
        builder.index("patent");

        //栏位
        Query q1 = QueryBuilders.term(t -> t.field("custom_field.project_id").value(projectId));


        Query q4 = QueryBuilders.term(t -> t.field("custom_field.field_type").value(10));

        Query parentQ1 = QueryBuilders.term(t -> t.field("app_no.keyword").value(patentNo));

        //公开号
        Query parentQ2 = QueryBuilders.term(t -> t.field("public_no.keyword").value(patentNo));

        //授权号
        Query parentQ3 = QueryBuilders.term(t -> t.field("grant_no.keyword").value(patentNo));

        Query parentQ = QueryBuilders.bool(i -> i.should(parentQ1, parentQ2, parentQ3));

        Query q3 = QueryBuilders.hasParent(t -> t.parentType("patent").query(parentQ));

        Query bool = null;
        bool = QueryBuilders.bool(i -> i.must(q1, q3, q4));


        builder.query(bool);
        SearchResponse<Patent> response = client.search(builder.build(), Patent.class);
        long total = response.hits().total().value();
        if (total > 0) {
            List<Hit<Patent>> hits = response.hits().hits();
            Hit<Patent> hit = hits.get(0);
            Patent patent = hit.source();
            patentWithIdVO.setPatent(patent);
            patentWithIdVO.setId(hit.id());
        } else {
            patentWithIdVO = null;
        }
        return patentWithIdVO;
    }


    public List<ESCustomField> getPatentCustomFields(String projectId, String patentId) {
        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("patent").id(patentId));
        Query bool = QueryBuilders.bool(i -> i.must(q1, q2));
        try {
            SearchResponse<Patent> response = client.search(builder.build(), Patent.class);
            List<Hit<Patent>> hits = response.hits().hits();
            hits.forEach(item -> {
            });
        } catch (Exception e) {

        }
        return null;
    }


    /**
     * 查询自定义栏位和值
     *
     * @param esQueryPatentFieldsDTO
     * @return
     * @throws Exception
     */
    public List<EsPatentFieldsVO> getPatentFields(EsQueryPatentFieldsDTO esQueryPatentFieldsDTO) throws Exception {
        List<EsPatentFieldsVO> esPatentFieldsVOS = new ArrayList<>();

        Integer projectId = esQueryPatentFieldsDTO.getProjectId();
        Integer taskId = esQueryPatentFieldsDTO.getTaskId();
        List<String> patentNos = esQueryPatentFieldsDTO.getPatentNos();
        List<InnerFields> innerFields = esQueryPatentFieldsDTO.getInnerFields();

        for (String patentNo : patentNos) {
            EsPatentFieldsVO esPatentFieldsVO = new EsPatentFieldsVO();
            esPatentFieldsVO.setPatentNo(patentNo);
            SearchRequest.Builder builder = new SearchRequest.Builder();

            //设置查询索引
            builder.index("patent");
            builder.sort(sortOptionsBuilder -> sortOptionsBuilder
                    .field(fieldSortBuilder -> fieldSortBuilder
                            .field("custom_field.create_time").order(SortOrder.Desc)));
            Query queries = this.getQueries(patentNo, innerFields, projectId, taskId);
            builder.size(999);
            builder.query(queries);
            SearchResponse<Patent> response = client.search(builder.build(), Patent.class);
            long total = response.hits().total().value();
            List<ESCustomField> esCustomFields = new ArrayList<>();
            List<InnerPatentFieldsVO> innerPatentFieldsVOS = new ArrayList<>();
            if (total > 0) {
                List<Hit<Patent>> hits = response.hits().hits();
                for (Hit<Patent> hit : hits) {
                    Patent patent = hit.source();
                    ESCustomField esCustomField = patent.getESCustomField();
                    ESCustomField esCustomField1 = esCustomFields.stream()
                            .filter(item -> item.getField().equals(esCustomField.getField()) && item.getFieldType().equals(esCustomField.getFieldType()))
                            .findFirst().orElse(null);

                    if (esCustomField1 == null) {
                        esCustomFields.add(esCustomField);
                        InnerPatentFieldsVO innerPatentFieldsVO = new InnerPatentFieldsVO();
                        innerPatentFieldsVO.setField(esCustomField.getField());
                        innerPatentFieldsVO.setFieldType(esCustomField.getFieldType());
                        List<FieldValueVO> fieldValueVOS = this.getCustomFieldValues(esCustomField.getFieldType(), esCustomField.getFieldValue());
                        innerPatentFieldsVO.setFieldValueVOS(fieldValueVOS);
                        innerPatentFieldsVOS.add(innerPatentFieldsVO);
                    }
                }
            }
            esPatentFieldsVO.setInnerClassFields(innerPatentFieldsVOS);
            esPatentFieldsVOS.add(esPatentFieldsVO);
        }

        return esPatentFieldsVOS;
    }

    private Query getQueries(String patentNo, List<InnerFields> innerFields, Integer projectId, Integer taskId) {

        Query parentQ1 = QueryBuilders.term(t -> t.field("app_no.keyword").value(patentNo));

        //公开号
        Query parentQ2 = QueryBuilders.term(t -> t.field("public_no.keyword").value(patentNo));

        //授权号
        Query parentQ3 = QueryBuilders.term(t -> t.field("grant_no.keyword").value(patentNo));

        Query parentQ = QueryBuilders.bool(i -> i.should(parentQ1, parentQ2, parentQ3));
        Query patentQ1 = QueryBuilders.hasParent(t -> t.parentType("patent").query(parentQ));
        List<Query> queries = new ArrayList<>();
        for (InnerFields innerField : innerFields) {
            String filedId = innerField.getFieldId();
            Integer fieldType = innerField.getFieldType();
            Query q1 = QueryBuilders.term(t -> t.field("custom_field.project_id").value(projectId));
            Query q2 = QueryBuilders.term((t -> t.field("custom_field.field").value(filedId)));
            Query q3 = QueryBuilders.term(t -> t.field("custom_field.field_type").value(fieldType));
            Query fQ =null;
            if (taskId != null) {
                Query q4 =QueryBuilders.term(t -> t.field("custom_field.task_id").value(taskId));
                fQ = QueryBuilders.bool(i -> i.must(q1, q2, q3,q4));
                queries.add(fQ);
            }
            else {
                 fQ = QueryBuilders.bool(i -> i.must(q1, q2, q3));
                queries.add(fQ);
            }
            queries.add(fQ);
        }
        Query query = QueryBuilders.bool(i -> i.should(queries));
        Query query1 = QueryBuilders.bool(i -> i.must(query, patentQ1));
        return query1;
    }


    /**
     * 获得自定义字段的值
     *
     * @param type
     * @param value
     * @return
     */
    public List<FieldValueVO> getCustomFieldValues(Integer type, List<String> value) {
        List<FieldValueVO> fieldValueVOS = new ArrayList<>();
        switch (type) {
            case 0:
            case 1:
            case 2:
            case 10:
                value.forEach(item -> {
                    FieldValueVO fieldValueVO = new FieldValueVO();
                    fieldValueVO.setValue(item);
                    fieldValueVOS.add(fieldValueVO);
                });
                break;
            case 3:
            case 4:
            case 5:
                if (value != null && value.size() > 0) {
                    List<Integer> ids = FormatUtil.StringTOIntegerList(value);
                    LambdaQueryWrapper<CustomOption> queryWrapper = new LambdaQueryWrapper<>();
                    queryWrapper.in(CustomOption::getId, ids);
                    List<CustomOption> customOptions = customOptionService.list(queryWrapper);
                    customOptions.forEach(item -> {
                        FieldValueVO fieldValueVO = new FieldValueVO();
                        fieldValueVO.setValueId(item.getId());
                        fieldValueVO.setValue(item.getName());
                        fieldValueVOS.add(fieldValueVO);
                    });
                }
                break;
            case 6:
            case 7:
            case 8:

            case 9:
                if (value != null && value.size() > 0) {
                    List<Integer> ids = FormatUtil.StringTOIntegerList(value);
                    LambdaQueryWrapper<TreeNode> queryWrapper = new LambdaQueryWrapper<>();
                    queryWrapper.in(TreeNode::getId, ids);
                    List<TreeNode> treeNodes = treeNodeService.list(queryWrapper);
                    treeNodes.forEach(item -> {
                        FieldValueVO fieldValueVO = new FieldValueVO();
                        fieldValueVO.setValueId(item.getId());

                        List<String> idStrs = new ArrayList<>();
                        List<String> pathNames = new ArrayList<>();
                        if (item.getPath() != null && !item.getPath().equals("")) {
                            idStrs = Arrays.asList(item.getPath().split("/"));
                            pathNames = treeNodeService.getBaseMapper().getTreeFieldPath(idStrs);

                        }
                        pathNames.add(item.getName());
                        String pathValue = cn.cslg.pas.common.utils.StringUtils.join(pathNames, "/");
                        fieldValueVO.setValue(pathValue);
                        fieldValueVO.setPath(item.getPath());
                        fieldValueVOS.add(fieldValueVO);
                    });
                }
                break;
        }
        return fieldValueVOS;

    }

    public CustomFiledRecord getEsCustomFields(String filedId, Integer type, Integer projectId, Long current, Long size) {
       CustomFiledRecord customFiledRecord =new CustomFiledRecord();
        Query q1 = QueryBuilders.term(t -> t.field("custom_field.project_id").value(projectId));
        Query q2 = QueryBuilders.term((t -> t.field("custom_field.field").value(filedId)));
        Query q3 = QueryBuilders.term(t -> t.field("custom_field.field_type").value(type));

        Query fQ = QueryBuilders.bool(i -> i.must(q1, q2, q3));
        SearchRequest.Builder builder = new SearchRequest.Builder();
        builder.query(fQ);
        builder.sort(sortOptionsBuilder -> sortOptionsBuilder
                .field(fieldSortBuilder -> fieldSortBuilder
                        .field("custom_field.create_time").order(SortOrder.Desc)));

        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);
        }
        try {
            SearchResponse<Patent> response = client.search(builder.build(), Patent.class);
            long total = response.hits().total().value();
            customFiledRecord.setTotal(total);
            if (total > 0) {
                List<Hit<Patent>> hits = response.hits().hits();
                for (Hit<Patent> hit : hits) {
               customFiledRecord.getPatents().add(hit.source());
                }

            }
        } catch (Exception e) {
        }

        return customFiledRecord;
    }


    public List<PatentWithIdVO> getEsCustomFields(String filedId, Integer type, Integer projectId) {
        List<PatentWithIdVO> patentWithIdVOS = new ArrayList<>();
        Query q1 = QueryBuilders.term(t -> t.field("custom_field.project_id").value(projectId));
        Query q2 = QueryBuilders.term((t -> t.field("custom_field.field").value(filedId)));
        Query q3 = QueryBuilders.term(t -> t.field("custom_field.field_type").value(type));

        Query fQ = QueryBuilders.bool(i -> i.must(q1, q2, q3));
        SearchRequest.Builder builder = new SearchRequest.Builder();
        builder.size(999);
        builder.query(fQ);
        builder.sort(sortOptionsBuilder -> sortOptionsBuilder
                .field(fieldSortBuilder -> fieldSortBuilder
                        .field("custom_field.create_time").order(SortOrder.Desc)));
        try {
            SearchResponse<Patent> response = client.search(builder.build(), Patent.class);
            long total = response.hits().total().value();
            if (total > 0) {
                List<Hit<Patent>> hits = response.hits().hits();
                for (Hit<Patent> hit : hits) {
                    PatentWithIdVO patentWithIdVO = new PatentWithIdVO();
                    patentWithIdVO.setPatent(hit.source());
                    patentWithIdVO.setId(hit.id());
                    PatentWithIdVO patentWithIdVO1 = patentWithIdVOS.stream().filter(item -> item.getPatent().getPatentJoin().getParent().equals(hit.source().getPatentJoin().getParent())).findFirst().orElse(null);
                    if (patentWithIdVO1 == null) {
                        patentWithIdVOS.add(patentWithIdVO);
                    }
                }

            }
        } catch (Exception e) {
        }

        return patentWithIdVOS;
    }
}