es聚合分析

src/main/java/cn/cslg/pas/controller/PatentController.java

@@ -53,7 +53,7 @@ public class PatentController {
         return Response.success(records);
     }
 
-    @Operation(summary = "统计专利库中专利")
+    @Operation(summary = "专利的聚合统计")
     @PostMapping("/esCountSearch")
     public Response esCountSearch(@RequestBody List<EsCountVO> countVOS) throws Exception {
         EsCountDTO dto = esCountService.esCountSearch(countVOS);
@@ -81,18 +81,11 @@ public class PatentController {
         return Response.success(patentPageMessageVOS);
     }
 
-//    @Operation(summary = "esSearch")
-//    @PostMapping("/esSearch")
-//    public Response esSearch(@RequestBody List<EsCustomFieldValueDTO> customFields) throws Exception {
-//        PatentDTO patentDTO = esService.esSearch(customFields);
-//        return Response.success(patentDTO);
-//    }
-
-//    @Operation(summary = "esCount")
-//    @PostMapping("/esCount")
-//    public Response esCount(@RequestBody EsCountVO countVO) throws Exception {
-//        EsCountDTO patentDTO = esCountService.esCount(countVO);
-//        return Response.success(patentDTO);
-//    }
+    @Operation(summary = "专利的聚合分析")
+    @PostMapping("/esAnalysisSearch")
+    public Response esCount(@RequestBody List<EsCountVO> countVOS) throws Exception {
+        EsCountDTO patentDTO = esCountService.esAnalysisSearch(countVOS);
+        return Response.success(patentDTO);
+    }
 
 }

src/main/java/cn/cslg/pas/factorys/EsAnalysisBuilderFactory/ChildAnalysisBuilder.java

@@ -4,6 +4,7 @@ import co.elastic.clients.elasticsearch._types.aggregations.Aggregation;
 import co.elastic.clients.elasticsearch._types.aggregations.AggregationBuilders;
 import co.elastic.clients.elasticsearch._types.aggregations.ChildrenAggregation;
 import co.elastic.clients.elasticsearch._types.aggregations.TermsAggregation;
+import org.apache.commons.lang3.StringUtils;
 import org.springframework.stereotype.Component;
 
 import java.util.HashMap;
@@ -18,27 +19,21 @@ public class ChildAnalysisBuilder implements IEsAnalysisBuilder {
 
     @Override
     public Aggregation createAnalyseAgg() {
-        Aggregation terms;
-        if (ifHaveChild) {
-            Aggregation agg = AggregationBuilders.terms(i -> i.field("custom_field.stats_value.raw").size(topN));
-            terms = new Aggregation.Builder().terms(new TermsAggregation.Builder()
+        Aggregation aggregation = null;
+        if (StringUtils.isNotEmpty(fieldValue)){
+            Aggregation filter = AggregationBuilders.filter(n -> n.term(m -> m.field("custom_field.field_value.raw")
+                    .value(fieldValue)));
+            Aggregation filterAgg = new Aggregation.Builder().terms(new TermsAggregation.Builder()
                     .field(field).size(topN).build())
                     .aggregations(new HashMap() {{
-                        put("filter_agg", agg);
-                    }}).build();
-        } else {
-            Aggregation agg = AggregationBuilders.terms(i -> i.field("custom_field.field_value.raw").size(topN));
-            terms = new Aggregation.Builder().terms(new TermsAggregation.Builder()
-                    .field(field).size(topN).build())
-                    .aggregations(new HashMap() {{
-                        put("filter_agg", agg);
+                        put("filter_agg", filter);
                     }}).build();
+            aggregation = new Aggregation.Builder().children(new ChildrenAggregation.Builder()
+                    .type("project_customfield").build()).aggregations(new HashMap() {{
+                put("child_agg", filterAgg);
+            }}).build();
         }
 
-        Aggregation aggregation = new Aggregation.Builder().children(new ChildrenAggregation.Builder()
-                .type("project_customfield").build()).aggregations(new HashMap() {{
-            put("child_agg", terms);
-        }}).build();
         return aggregation;
     }
 

src/main/java/cn/cslg/pas/factorys/EsAnalysisBuilderFactory/DateAnalysisBuilder.java

@@ -9,6 +9,10 @@ import co.elastic.clients.elasticsearch._types.query_dsl.QueryBuilders;
 import org.apache.commons.lang3.StringUtils;
 import org.springframework.stereotype.Component;
 
+import java.text.ParseException;
+import java.text.SimpleDateFormat;
+import java.util.Calendar;
+import java.util.Date;
 import java.util.HashMap;
 
 @Component
@@ -18,14 +22,25 @@ public class DateAnalysisBuilder implements IEsAnalysisBuilder {
     public Integer topN = 10;
     public String path = "";
     public Boolean ifHaveChild = false;
+    public static final int YEAR = 4;
+    public static final int YEARRANGE = 9;
+    public static final int MONTH = 7;
+    public static final int DAYONE = 8;
+    public static final int DAY = 10;
 
     @Override
-    public Aggregation createAnalyseAgg() {
-//        Aggregation aggregation = AggregationBuilders.dateHistogram(i -> i.field(field).format("yyyy").calendarInterval(CalendarInterval.Year));
+    public Aggregation createAnalyseAgg() throws ParseException {
         Aggregation aggregation = null;
         if (StringUtils.isNotEmpty(fieldValue)) {
-            if (fieldValue.length() == 4) {
-                Query query = QueryBuilders.term(i -> i.field(field).value(fieldValue));
+            Calendar calendar = Calendar.getInstance();
+            if (fieldValue.length() == YEAR) {
+                SimpleDateFormat format = new SimpleDateFormat("yyyy");
+                Date year = format.parse(fieldValue);
+                calendar.setTime(year);
+                calendar.add(Calendar.YEAR, 1);
+                Date yearDate = calendar.getTime();
+                String nextYear = format.format(yearDate);
+                Query query = QueryBuilders.range(j -> j.field(field).from(fieldValue).to(nextYear).format("yyyy"));
                 Aggregation filter = AggregationBuilders.filter(n -> n.bool(k -> k.must(query)));
                 aggregation = new Aggregation.Builder().dateHistogram(new DateHistogramAggregation.Builder()
                         .field(field).format("yyyy")
@@ -33,8 +48,15 @@ public class DateAnalysisBuilder implements IEsAnalysisBuilder {
                         .aggregations(new HashMap() {{
                             put("filter_agg", filter);
                         }}).build();
-            } else if (fieldValue.length() == 6) {
-                Query query = QueryBuilders.term(i -> i.field(field).value(fieldValue));
+            } else if (fieldValue.length() == MONTH && !fieldValue.contains("Q")
+                    && !fieldValue.contains("H")) {
+                SimpleDateFormat format = new SimpleDateFormat("yyyy-MM");
+                Date month = format.parse(fieldValue);
+                calendar.setTime(month);
+                calendar.add(Calendar.MONTH, 1);
+                Date monthDate = calendar.getTime();
+                String nextMonth = format.format(monthDate);
+                Query query = QueryBuilders.range(j -> j.field(field).from(fieldValue).to(nextMonth).format("yyyy-MM"));
                 Aggregation filter = AggregationBuilders.filter(n -> n.bool(k -> k.must(query)));
                 aggregation = new Aggregation.Builder().dateHistogram(new DateHistogramAggregation.Builder()
                         .field(field).format("yyyy-MM")
@@ -42,21 +64,118 @@ public class DateAnalysisBuilder implements IEsAnalysisBuilder {
                         .aggregations(new HashMap() {{
                             put("filter_agg", filter);
                         }}).build();
-            } else if (fieldValue.contains("Q")) {
-                Query query = QueryBuilders.term(i -> i.field(field).value(fieldValue));
-                Aggregation filter = AggregationBuilders.filter(n -> n.bool(k -> k.must(query)));
-                aggregation = new Aggregation.Builder().dateHistogram(new DateHistogramAggregation.Builder()
-                        .field(field).format("yyyy-MM")
-                        .calendarInterval(CalendarInterval.Quarter).build())
-                        .aggregations(new HashMap() {{
-                            put("filter_agg", filter);
-                        }}).build();
-            } else if (fieldValue.contains("H")) {
 
+            } else if (fieldValue.length() == MONTH && fieldValue.contains("Q")) {
+                if (fieldValue.contains("Q1")) {
+                    String firstQuarter = fieldValue.substring(0, fieldValue.indexOf("-"));
+                    String firstQuarterDate = firstQuarter + "-01";
+                    SimpleDateFormat format = new SimpleDateFormat("yyyy-MM");
+                    Date quarter = format.parse(firstQuarterDate);
+                    calendar.setTime(quarter);
+                    calendar.add(Calendar.MONTH, 3);
+                    Date quarterDate = calendar.getTime();
+                    String nextQuarterDate = format.format(quarterDate);
+                    Query query = QueryBuilders.range(j -> j.field(field).from(firstQuarterDate).to(nextQuarterDate).format("yyyy-MM"));
+                    Aggregation filter = AggregationBuilders.filter(n -> n.bool(k -> k.must(query)));
+                    aggregation = new Aggregation.Builder().dateHistogram(new DateHistogramAggregation.Builder()
+                            .field(field).format("yyyy-MM")
+                            .calendarInterval(CalendarInterval.Quarter).build())
+                            .aggregations(new HashMap() {{
+                                put("filter_agg", filter);
+                            }}).build();
+                } else if (fieldValue.contains("Q2")) {
+                    String secondQuarter = fieldValue.substring(0, fieldValue.indexOf("-"));
+                    String secondQuarterDate = secondQuarter + "-04";
+                    SimpleDateFormat format = new SimpleDateFormat("yyyy-MM");
+                    Date quarter = format.parse(secondQuarterDate);
+                    calendar.setTime(quarter);
+                    calendar.add(Calendar.MONTH, 3);
+                    Date quarterDate = calendar.getTime();
+                    String nextQuarterDate = format.format(quarterDate);
+                    Query query = QueryBuilders.range(j -> j.field(field).from(secondQuarterDate).to(nextQuarterDate).format("yyyy-MM"));
+                    Aggregation filter = AggregationBuilders.filter(n -> n.bool(k -> k.must(query)));
+                    aggregation = new Aggregation.Builder().dateHistogram(new DateHistogramAggregation.Builder()
+                            .field(field).format("yyyy-MM")
+                            .calendarInterval(CalendarInterval.Quarter).build())
+                            .aggregations(new HashMap() {{
+                                put("filter_agg", filter);
+                            }}).build();
+                } else if (fieldValue.contains("Q3")) {
+                    String thirdQuarter = fieldValue.substring(0, fieldValue.indexOf("-"));
+                    String thirdQuarterDate = thirdQuarter + "-07";
+                    SimpleDateFormat format = new SimpleDateFormat("yyyy-MM");
+                    Date quarter = format.parse(thirdQuarterDate);
+                    calendar.setTime(quarter);
+                    calendar.add(Calendar.MONTH, 3);
+                    Date quarterDate = calendar.getTime();
+                    String nextQuarterDate = format.format(quarterDate);
+                    Query query = QueryBuilders.range(j -> j.field(field).from(thirdQuarterDate).to(nextQuarterDate).format("yyyy-MM"));
+                    Aggregation filter = AggregationBuilders.filter(n -> n.bool(k -> k.must(query)));
+                    aggregation = new Aggregation.Builder().dateHistogram(new DateHistogramAggregation.Builder()
+                            .field(field).format("yyyy-MM")
+                            .calendarInterval(CalendarInterval.Quarter).build())
+                            .aggregations(new HashMap() {{
+                                put("filter_agg", filter);
+                            }}).build();
+                } else if (fieldValue.contains("Q4")) {
+                    String fourthQuarter = fieldValue.substring(0, fieldValue.indexOf("-"));
+                    String fourthQuarterDate = fourthQuarter + "-10";
+                    SimpleDateFormat format = new SimpleDateFormat("yyyy-MM");
+                    Date quarter = format.parse(fourthQuarterDate);
+                    calendar.setTime(quarter);
+                    calendar.add(Calendar.MONTH, 3);
+                    Date quarterDate = calendar.getTime();
+                    String nextQuarterDate = format.format(quarterDate);
+                    Query query = QueryBuilders.range(j -> j.field(field).from(fourthQuarterDate).to(nextQuarterDate).format("yyyy-MM"));
+                    Aggregation filter = AggregationBuilders.filter(n -> n.bool(k -> k.must(query)));
+                    aggregation = new Aggregation.Builder().dateHistogram(new DateHistogramAggregation.Builder()
+                            .field(field).format("yyyy-MM")
+                            .calendarInterval(CalendarInterval.Quarter).build())
+                            .aggregations(new HashMap() {{
+                                put("filter_agg", filter);
+                            }}).build();
+                }
+            } else if (fieldValue.length() == MONTH && fieldValue.contains("H")) {
+                if (fieldValue.contains("H1")) {
+                    String firstHalfYear = fieldValue.substring(0, fieldValue.indexOf("-"));
+                    String firstHalfYearDate = firstHalfYear + "-01";
+                    SimpleDateFormat format = new SimpleDateFormat("yyyy-MM");
+                    Date halfYear = format.parse(firstHalfYearDate);
+                    calendar.setTime(halfYear);
+                    calendar.add(Calendar.MONTH, 6);
+                    Date halfYearDate = calendar.getTime();
+                    String nextHalfYearDate = format.format(halfYearDate);
+                    Query query = QueryBuilders.range(j -> j.field(field).from(firstHalfYearDate).to(nextHalfYearDate).format("yyyy-MM"));
+                    Aggregation filter = AggregationBuilders.filter(n -> n.bool(k -> k.must(query)));
+                    aggregation = new Aggregation.Builder().dateHistogram(new DateHistogramAggregation.Builder()
+                            .field(field).format("yyyy-MM")
+                            .calendarInterval(CalendarInterval.Month).build())
+                            .aggregations(new HashMap() {{
+                                put("filter_agg", filter);
+                            }}).build();
+                } else if (fieldValue.contains("H2")) {
+                    String secondHalfYear = fieldValue.substring(0, fieldValue.indexOf("-"));
+                    String secondHalfYearDate = secondHalfYear + "-07";
+                    SimpleDateFormat format = new SimpleDateFormat("yyyy-MM");
+                    Date halfYear = format.parse(secondHalfYearDate);
+                    calendar.setTime(halfYear);
+                    calendar.add(Calendar.MONTH, 6);
+                    Date halfYearDate = calendar.getTime();
+                    String nextHalfYearDate = format.format(halfYearDate);
+                    Query query = QueryBuilders.range(j -> j.field(field).from(secondHalfYearDate).to(nextHalfYearDate).format("yyyy-MM"));
+                    Aggregation filter = AggregationBuilders.filter(n -> n.bool(k -> k.must(query)));
+                    aggregation = new Aggregation.Builder().dateHistogram(new DateHistogramAggregation.Builder()
+                            .field(field).format("yyyy-MM")
+                            .calendarInterval(CalendarInterval.Month).build())
+                            .aggregations(new HashMap() {{
+                                put("filter_agg", filter);
+                            }}).build();
+                }
             } else {
                 String start = fieldValue.substring(0, fieldValue.indexOf("-"));
-                String end = fieldValue.substring(fieldValue.indexOf("-"));
-                Query query = QueryBuilders.range(j -> j.field(field).from(start).to(end));
+                String end = fieldValue.substring(fieldValue.indexOf("-") + 1);
+                String nextYear = String.valueOf(Integer.parseInt(end) + 1);
+                Query query = QueryBuilders.range(j -> j.field(field).from(start).to(nextYear).format("yyyy"));
                 Aggregation filter = AggregationBuilders.filter(n -> n.bool(k -> k.must(query)));
                 aggregation = new Aggregation.Builder().dateHistogram(new DateHistogramAggregation.Builder()
                         .field(field).format("yyyy")
@@ -65,7 +184,6 @@ public class DateAnalysisBuilder implements IEsAnalysisBuilder {
                             put("filter_agg", filter);
                         }}).build();
             }
-
         }
         return aggregation;
     }

src/main/java/cn/cslg/pas/factorys/EsAnalysisBuilderFactory/RangeAnalysisBuilder.java

@@ -22,7 +22,7 @@ public class RangeAnalysisBuilder implements IEsAnalysisBuilder {
         if (StringUtils.isNotEmpty(fieldValue)) {
             if (fieldValue.contains("-")) {
                 String start = fieldValue.substring(0, fieldValue.indexOf("-"));
-                String end = fieldValue.substring(fieldValue.indexOf("-"));
+                String end = fieldValue.substring(fieldValue.indexOf("-") + 1);
                 end = String.valueOf(Integer.parseInt(end) + 1);
                 String finalEnd = end;
                 aggregation = AggregationBuilders.range(i -> i.field(field)

src/main/java/cn/cslg/pas/factorys/EsCountBuilderFactory/DateHistogramBuilder.java

@@ -24,7 +24,7 @@ public class DateHistogramBuilder implements IEsCountBuilder{
     public Aggregation createAggregation() {
         Aggregation aggregation = AggregationBuilders.dateHistogram(i -> i.field(field).format("yyyy").calendarInterval(CalendarInterval.Year));
         if (StringUtils.isNotEmpty(valueOne) && StringUtils.isNotEmpty(valueTwo)) {
-            Query query = QueryBuilders.range(j -> j.field(field).from(valueOne).to(valueTwo));
+            Query query = QueryBuilders.range(j -> j.field(field).from(valueOne).to(valueTwo).format("yyyy"));
             Aggregation filter = AggregationBuilders.filter(n -> n.bool(k -> k.must(query)));
             aggregation = new Aggregation.Builder().dateHistogram(new DateHistogramAggregation.Builder()
                     .field(field).format("yyyy")

src/main/java/cn/cslg/pas/service/business/es/EsCountService.java

@@ -28,8 +28,6 @@ import org.springframework.context.annotation.Lazy;
 import org.springframework.stereotype.Service;
 import org.springframework.util.CollectionUtils;
 
-import java.io.IOException;
-import java.text.ParseException;
 import java.util.*;
 import java.util.stream.Collectors;
 
@@ -137,6 +135,13 @@ public class EsCountService {
         return esCountDTO;
     }
 
+    /**
+     * 专利的聚合分析
+     *
+     * @param countVOS
+     * @return
+     * @throws Exception
+     */
     public EsCountDTO esAnalysisSearch(List<EsCountVO> countVOS) throws Exception {
         EsCountDTO esCountDTO = new EsCountDTO();
         List<EsCountDetailDTO> detailDTOS = new ArrayList<>();
@@ -158,11 +163,11 @@ public class EsCountService {
                 iEsAnalysisBuilder.setField(esConfigVO.getEsField());
                 iEsAnalysisBuilder.setTopN(topN);
                 iEsAnalysisBuilder.setIfHaveChild(ifHaveChild);
-                if (iEsAnalysisBuilder.getField().contains(".")) {
-                    String path = iEsAnalysisBuilder.getField().substring(0, iEsAnalysisBuilder.getField().indexOf("."));
-                    iEsAnalysisBuilder.setPath(path);
-                }
                 for (String value : values) {
+                    if (iEsAnalysisBuilder.getField().contains(".")) {
+                        String path = iEsAnalysisBuilder.getField().substring(0, iEsAnalysisBuilder.getField().indexOf("."));
+                        iEsAnalysisBuilder.setPath(path);
+                    }
                     iEsAnalysisBuilder.setFieldValue(value);
                     Aggregation aggregation = iEsAnalysisBuilder.createAnalyseAgg();
                     builder.aggregations("Agg", aggregation);
@@ -170,17 +175,65 @@ public class EsCountService {
 
                     Aggregate agg = response.aggregations().get("Agg");
                     if (dateList.contains(field)) {
-                        this.getDateCountDTOS(agg, field, topN, detailDTOS);
+                        this.getDateAnalysisDTOS(agg, field, value, topN, detailDTOS);
                     } else if (nestedList.contains(field)) {
                         this.getNestedCountDTOS(agg, field, detailDTOS);
                     } else if (childList.contains(field)) {
-                        this.getChildCountDTOS(agg, field, detailDTOS);
-                    } else if (childList.contains(field)) {
-                        this.getChildCountDTOS(agg, field, detailDTOS);
+                        this.getChildAnalysisDTOS(agg, field, value, detailDTOS);
+                    } else if (numberList.contains(field)) {
+                        this.getNumberAnalysisDTOS(agg, field, value, detailDTOS);
                     } else {
                         this.getTermCountDTOS(agg, field, detailDTOS);
                     }
+                }
+            }
+        }
+        esCountDTO.setDetailDTOS(detailDTOS);
+        return esCountDTO;
+    }
+
+    public EsCountDTO esAnalysisSearch(EsCountVO vo) throws Exception {
+        EsCountDTO esCountDTO = new EsCountDTO();
+        List<EsCountDetailDTO> detailDTOS = new ArrayList<>();
+        String field = vo.getField();
+        Integer topN = vo.getTopN();
+        Boolean ifHaveChild = vo.getIfHaveChild();
+        List<String> values = vo.getValues();
+
+        //查询es返回数据
+        SearchRequest.Builder builder = new SearchRequest.Builder();
+        builder.index("patent");
+        IEsAnalysisBuilder iEsAnalysisBuilder = null;
+        String json = CommonService.readJsonFile("esAnalysis.json");
+        List<EsConfigVO> esConfigVOS = JSON.parseArray(json, EsConfigVO.class);
+        EsConfigVO esConfigVO = esConfigVOS.stream().filter(item -> item.getField().equals(field))
+                .findFirst().orElse(null);
+        if (esConfigVO != null) {
+            iEsAnalysisBuilder = esAnalysisBuilderFactory.getClass(esConfigVO.getEsClass());
+            iEsAnalysisBuilder.setField(esConfigVO.getEsField());
+            iEsAnalysisBuilder.setTopN(topN);
+            iEsAnalysisBuilder.setIfHaveChild(ifHaveChild);
+            for (String value : values) {
+                if (iEsAnalysisBuilder.getField().contains(".")) {
+                    String path = iEsAnalysisBuilder.getField().substring(0, iEsAnalysisBuilder.getField().indexOf("."));
+                    iEsAnalysisBuilder.setPath(path);
+                }
+                iEsAnalysisBuilder.setFieldValue(value);
+                Aggregation aggregation = iEsAnalysisBuilder.createAnalyseAgg();
+                builder.aggregations("Agg", aggregation);
+                SearchResponse<Patent> response = client.search(builder.build(), Patent.class);
 
+                Aggregate agg = response.aggregations().get("Agg");
+                if (dateList.contains(field)) {
+                    this.getDateAnalysisDTOS(agg, field, value, topN, detailDTOS);
+                } else if (nestedList.contains(field)) {
+                    this.getNestedCountDTOS(agg, field, detailDTOS);
+                } else if (childList.contains(field)) {
+                    this.getChildAnalysisDTOS(agg, field, value, detailDTOS);
+                } else if (numberList.contains(field)) {
+                    this.getNumberAnalysisDTOS(agg, field, value, detailDTOS);
+                } else {
+                    this.getTermCountDTOS(agg, field, detailDTOS);
                 }
             }
         }
@@ -309,6 +362,50 @@ public class EsCountService {
     }
 
     /**
+     * 获取children分析后数据
+     *
+     * @param agg
+     * @param field
+     * @param value
+     * @param detailDTOS
+     */
+    public void getChildAnalysisDTOS(Aggregate agg, String field, String value, List<EsCountDetailDTO> detailDTOS) {
+        Aggregate childAgg = agg.children().aggregations().get("child_agg");
+        List<StringTermsBucket> list = childAgg.sterms().buckets().array();
+        list.forEach(bucket -> {
+            EsCountDetailDTO dto = new EsCountDetailDTO();
+            dto.setField(field);
+            Aggregate aggregate = bucket.aggregations().get("filter_agg");
+            dto.setName(value);
+            dto.setNumber(aggregate.filter().docCount());
+            if (dto.getNumber() > 0) {
+                detailDTOS.add(dto);
+            }
+        });
+    }
+
+    /**
+     * 获取range分析后数据
+     *
+     * @param agg
+     * @param field
+     * @param value
+     * @param detailDTOS
+     */
+    public void getNumberAnalysisDTOS(Aggregate agg, String field,String value, List<EsCountDetailDTO> detailDTOS) {
+        List<RangeBucket> list = agg.range().buckets().array();
+        list.forEach(bucket -> {
+            EsCountDetailDTO dto = new EsCountDetailDTO();
+            dto.setField(field);
+            dto.setName(value);
+            dto.setNumber(bucket.docCount());
+            if (dto.getNumber() > 0) {
+                detailDTOS.add(dto);
+            }
+        });
+    }
+
+    /**
      * 获取dateHistogram聚合后数据
      *
      * @param agg
@@ -339,6 +436,55 @@ public class EsCountService {
     }
 
     /**
+     * 获取dateHistogram分析后数据
+     *
+     * @param agg
+     * @param field
+     * @param value
+     * @param topN
+     * @param detailDTOS
+     */
+    public void getDateAnalysisDTOS(Aggregate agg, String field, String value, Integer topN, List<EsCountDetailDTO> detailDTOS) {
+        List<DateHistogramBucket> list = agg.dateHistogram().buckets().array();
+        List<EsCountDetailDTO> esCountDetailDTOS = new ArrayList<>();
+        if (value.contains("H")) {
+            long sum = 0L;
+            for (DateHistogramBucket bucket : list) {
+                Aggregate aggregate = bucket.aggregations().get("filter_agg");
+                long docCount = aggregate.filter().docCount();
+                sum += docCount;
+            }
+            EsCountDetailDTO dto = new EsCountDetailDTO();
+            dto.setField(field);
+            dto.setName(value);
+            dto.setNumber(sum);
+            if (dto.getNumber() > 0) {
+                esCountDetailDTOS.add(dto);
+            }
+        } else {
+            list.forEach(bucket -> {
+                EsCountDetailDTO dto = new EsCountDetailDTO();
+                dto.setField(field);
+                Aggregate aggregate = bucket.aggregations().get("filter_agg");
+                dto.setName(value);
+                dto.setNumber(bucket.docCount());
+                if (aggregate != null) {
+                    dto.setNumber(aggregate.filter().docCount());
+                }
+                if (dto.getNumber() > 0) {
+                    esCountDetailDTOS.add(dto);
+                }
+            });
+        }
+
+        if (!CollectionUtils.isEmpty(esCountDetailDTOS)) {
+            List<EsCountDetailDTO> collect = esCountDetailDTOS.stream()
+                    .sorted(Comparator.comparing(EsCountDetailDTO::getName).reversed()).limit(topN).collect(Collectors.toList());
+            detailDTOS.addAll(collect);
+        }
+    }
+
+    /**
      * 获取nested聚合后数据
      *
      * @param agg