es统计分析

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

@@ -1,15 +1,9 @@
 package cn.cslg.pas.factorys.EsAnalysisBuilderFactory;
 
 import co.elastic.clients.elasticsearch._types.aggregations.*;
-import co.elastic.clients.elasticsearch._types.query_dsl.Query;
-import co.elastic.clients.elasticsearch._types.query_dsl.QueryBuilders;
-import co.elastic.clients.json.JsonData;
-import org.apache.commons.lang3.StringUtils;
 import org.springframework.stereotype.Component;
-import org.springframework.util.CollectionUtils;
 
 import java.util.ArrayList;
-import java.util.HashMap;
 import java.util.List;
 
 @Component

src/main/java/cn/cslg/pas/factorys/EsCountAnalyseBuilderFactory/DateCountAnalyssBuilder.java

@@ -0,0 +1,279 @@
+package cn.cslg.pas.factorys.EsCountAnalyseBuilderFactory;
+
+import cn.cslg.pas.factorys.EsCountBuilderFactory.IEsCountBuilder;
+import co.elastic.clients.elasticsearch._types.aggregations.*;
+import co.elastic.clients.elasticsearch._types.query_dsl.Query;
+import co.elastic.clients.elasticsearch._types.query_dsl.QueryBuilders;
+import org.apache.commons.lang3.StringUtils;
+import org.springframework.stereotype.Component;
+import org.springframework.util.CollectionUtils;
+
+import java.text.SimpleDateFormat;
+import java.util.*;
+
+@Component
+public class DateCountAnalyssBuilder implements IEsCountAnalysisBuilder {
+    public String field = "";
+    public String valueOne = "";
+    public String valueTwo = "";
+    public Integer topN = 10;
+    public String path = "";
+    public Boolean ifHaveChild = false;
+    public String fieldType = null;
+    public String fieldId = null;
+    private String format;
+    public List<String> values = new ArrayList<>();
+    public static final int YEAR = 4;
+    public static final int MONTH = 7;
+    public static final int DAY = 10;
+
+    @Override
+    public Aggregation createCountAnalyseAgg() throws Exception {
+        Aggregation aggregation = null;
+        if (StringUtils.isNotEmpty(valueOne) && StringUtils.isNotEmpty(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")
+                    .calendarInterval(CalendarInterval.Year).build())
+                    .aggregations(new HashMap() {{
+                        put("filter_agg", filter);
+                    }}).build();
+        } else if (!CollectionUtils.isEmpty(values)) {
+            List<DateRangeExpression> rangeExpressions = new ArrayList<>();
+            Calendar calendar = Calendar.getInstance();
+            for (String value : values) {
+                if (value.length() == YEAR) {
+                    SimpleDateFormat format = new SimpleDateFormat("yyyy-MM");
+                    String startYear = value + "-01";
+                    Date year = format.parse(startYear);
+                    calendar.setTime(year);
+                    calendar.add(Calendar.YEAR, 1);
+                    Date yearDate = calendar.getTime();
+                    String nextYear = format.format(yearDate);
+                    FieldDateMath st = FieldDateMath.of(i -> i.expr(startYear));
+                    FieldDateMath ed = FieldDateMath.of(i -> i.expr(nextYear));
+                    DateRangeExpression expression = DateRangeExpression.of(i -> i.from(st).to(ed).key(value));
+                    rangeExpressions.add(expression);
+                } else if (value.length() == MONTH && !value.contains("Q")
+                        && !value.contains("H")) {
+                    SimpleDateFormat format = new SimpleDateFormat("yyyy-MM");
+                    Date month = format.parse(value);
+                    calendar.setTime(month);
+                    calendar.add(Calendar.MONTH, 1);
+                    Date monthDate = calendar.getTime();
+                    String nextMonth = format.format(monthDate);
+                    FieldDateMath st = FieldDateMath.of(i -> i.expr(value));
+                    FieldDateMath ed = FieldDateMath.of(i -> i.expr(nextMonth));
+                    DateRangeExpression expression = DateRangeExpression.of(i -> i.from(st).to(ed).key(value));
+                    rangeExpressions.add(expression);
+                } else if (value.length() == MONTH && value.contains("Q")) {
+                    if (value.contains("Q1")) {
+                        String firstQuarter = value.substring(0, value.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);
+                        FieldDateMath st = FieldDateMath.of(i -> i.expr(firstQuarterDate));
+                        FieldDateMath ed = FieldDateMath.of(i -> i.expr(nextQuarterDate));
+                        DateRangeExpression expression = DateRangeExpression.of(i -> i.from(st).to(ed).key(value));
+                        rangeExpressions.add(expression);
+                    } else if (value.contains("Q2")) {
+                        String secondQuarter = value.substring(0, value.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);
+                        FieldDateMath st = FieldDateMath.of(i -> i.expr(secondQuarterDate));
+                        FieldDateMath ed = FieldDateMath.of(i -> i.expr(nextQuarterDate));
+                        DateRangeExpression expression = DateRangeExpression.of(i -> i.from(st).to(ed).key(value));
+                        rangeExpressions.add(expression);
+                    } else if (value.contains("Q3")) {
+                        String thirdQuarter = value.substring(0, value.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);
+                        FieldDateMath st = FieldDateMath.of(i -> i.expr(thirdQuarterDate));
+                        FieldDateMath ed = FieldDateMath.of(i -> i.expr(nextQuarterDate));
+                        DateRangeExpression expression = DateRangeExpression.of(i -> i.from(st).to(ed).key(value));
+                        rangeExpressions.add(expression);
+                    } else if (value.contains("Q4")) {
+                        String fourthQuarter = value.substring(0, value.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);
+                        FieldDateMath st = FieldDateMath.of(i -> i.expr(fourthQuarterDate));
+                        FieldDateMath ed = FieldDateMath.of(i -> i.expr(nextQuarterDate));
+                        DateRangeExpression expression = DateRangeExpression.of(i -> i.from(st).to(ed).key(value));
+                        rangeExpressions.add(expression);
+                    }
+                } else if (value.length() == MONTH && value.contains("H")) {
+                    if (value.contains("H1")) {
+                        String firstHalfYear = value.substring(0, value.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);
+                        FieldDateMath st = FieldDateMath.of(i -> i.expr(firstHalfYearDate));
+                        FieldDateMath ed = FieldDateMath.of(i -> i.expr(nextHalfYearDate));
+                        DateRangeExpression expression = DateRangeExpression.of(i -> i.from(st).to(ed).key(value));
+                        rangeExpressions.add(expression);
+                    } else if (value.contains("H2")) {
+                        String secondHalfYear = value.substring(0, value.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);
+                        FieldDateMath st = FieldDateMath.of(i -> i.expr(secondHalfYearDate));
+                        FieldDateMath ed = FieldDateMath.of(i -> i.expr(nextHalfYearDate));
+                        DateRangeExpression expression = DateRangeExpression.of(i -> i.from(st).to(ed).key(value));
+                        rangeExpressions.add(expression);
+                    }
+                } else {
+                    String start = value.substring(0, value.indexOf("-")) + "-01";
+                    String end = value.substring(value.indexOf("-") + 1);
+                    String nextYear = String.valueOf(Integer.parseInt(end) + 1) + "-01";
+                    FieldDateMath st = FieldDateMath.of(i -> i.expr(start));
+                    FieldDateMath ed = FieldDateMath.of(i -> i.expr(nextYear));
+                    DateRangeExpression expression = DateRangeExpression.of(i -> i.from(st).to(ed).key(value));
+                    rangeExpressions.add(expression);
+                }
+            }
+            aggregation = AggregationBuilders.dateRange(i -> i.field(field).format("yyyy-MM").ranges(rangeExpressions));
+        } else if (StringUtils.isNotEmpty(format) && CollectionUtils.isEmpty(values)) {
+            if (format.equals("年")) {
+                aggregation = AggregationBuilders.dateHistogram(i -> i.field(field).format("yyyy").calendarInterval(CalendarInterval.Year));
+            } else if (format.equals("半年")) {
+                aggregation = AggregationBuilders.dateHistogram(i -> i.field(field).format("yyyy-MM").calendarInterval(CalendarInterval.Year));
+            } else if (format.equals("季")) {
+                aggregation = AggregationBuilders.dateHistogram(i -> i.field(field).format("yyyy-MM").calendarInterval(CalendarInterval.Quarter));
+            } else if (format.equals("月")) {
+                aggregation = AggregationBuilders.dateHistogram(i -> i.field(field).format("yyyy-MM").calendarInterval(CalendarInterval.Month));
+            }
+        } else {
+            aggregation = AggregationBuilders.dateHistogram(i -> i.field(field).format("yyyy").calendarInterval(CalendarInterval.Year));
+
+        }
+        return aggregation;
+    }
+
+    @Override
+    public String getField() {
+        return field;
+    }
+
+    @Override
+    public void setField(String field) {
+        this.field = field;
+    }
+
+    @Override
+    public String getValueOne() {
+        return valueOne;
+    }
+
+    @Override
+    public void setValueOne(String valueOne) {
+        this.valueOne = valueOne;
+    }
+
+    @Override
+    public String getValueTwo() {
+        return valueTwo;
+    }
+
+    @Override
+    public void setValueTwo(String valueTwo) {
+        this.valueTwo = valueTwo;
+    }
+
+    @Override
+    public Integer getTopN() {
+        return topN;
+    }
+
+    @Override
+    public void setTopN(Integer topN) {
+        this.topN = topN;
+    }
+
+    @Override
+    public String getPath() {
+        return path;
+    }
+
+    @Override
+    public void setPath(String path) {
+        this.path = path;
+    }
+
+    @Override
+    public Boolean getIfHaveChild() {
+        return ifHaveChild;
+    }
+
+    @Override
+    public void setIfHaveChild(Boolean ifHaveChild) {
+        this.ifHaveChild = ifHaveChild;
+    }
+
+    @Override
+    public String getFieldType() {
+        return fieldType;
+    }
+
+    @Override
+    public void setFieldType(String fieldType) {
+        this.fieldType = fieldType;
+    }
+
+    @Override
+    public String getFieldId() {
+        return fieldId;
+    }
+
+    @Override
+    public void setFieldId(String fieldId) {
+        this.fieldId = fieldId;
+    }
+
+    @Override
+    public String getFormat() {
+        return format;
+    }
+
+    @Override
+    public void setFormat(String format) {
+        this.format = format;
+    }
+
+    @Override
+    public List<String> getValues() {
+        return values;
+    }
+
+    @Override
+    public void setValues(List<String> values) {
+        this.values = values;
+    }
+}

src/main/java/cn/cslg/pas/factorys/EsCountAnalyseBuilderFactory/EsCountAnalysisBuilderFactory.java

@@ -1,6 +1,5 @@
 package cn.cslg.pas.factorys.EsCountAnalyseBuilderFactory;
 
-import cn.cslg.pas.factorys.EsAnalysisBuilderFactory.IEsAnalysisBuilder;
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.stereotype.Component;
 

src/main/java/cn/cslg/pas/factorys/EsCountAnalyseBuilderFactory/IEsCountAnalysisBuilder.java

@@ -15,6 +15,7 @@ public interface IEsCountAnalysisBuilder {
     public String fieldType = null;
     public String fieldId = null;
     public List<String> values = new ArrayList<>();
+    public String format = null;
 
     public Aggregation createCountAnalyseAgg() throws Exception;
 
@@ -53,4 +54,8 @@ public interface IEsCountAnalysisBuilder {
 
     public void setValues(List<String> values);
 
+    public String getFormat();
+
+    public void setFormat(String format);
+
 }

src/main/java/cn/cslg/pas/factorys/EsCountAnalyseBuilderFactory/NestedCountAnalysisBuilder.java

@@ -24,6 +24,7 @@ public class NestedCountAnalysisBuilder implements IEsCountAnalysisBuilder {
     public Boolean ifHaveChild = false;
     public String fieldType = null;
     public String fieldId = null;
+    private String format;
     public List<String> values = new ArrayList<>();
 
     @Override
@@ -125,4 +126,11 @@ public class NestedCountAnalysisBuilder implements IEsCountAnalysisBuilder {
         this.values = values;
     }
 
+    public String getFormat() {
+        return format;
+    }
+
+    public void setFormat(String format) {
+        this.format = format;
+    }
 }

src/main/java/cn/cslg/pas/factorys/EsCountAnalyseBuilderFactory/RangeCountAnalysisBuilder.java

@@ -0,0 +1,152 @@
+package cn.cslg.pas.factorys.EsCountAnalyseBuilderFactory;
+
+import co.elastic.clients.elasticsearch._types.aggregations.Aggregation;
+import co.elastic.clients.elasticsearch._types.aggregations.AggregationBuilders;
+import co.elastic.clients.elasticsearch._types.aggregations.AggregationRange;
+import org.springframework.stereotype.Component;
+import org.springframework.util.CollectionUtils;
+
+import java.util.ArrayList;
+import java.util.List;
+
+@Component
+public class RangeCountAnalysisBuilder implements IEsCountAnalysisBuilder{
+    public String field = "";
+    public String valueOne = "";
+    public String valueTwo = "";
+    public Integer topN = 10;
+    public String path = "";
+    public Boolean ifHaveChild = false;
+    public String fieldType = null;
+    public String fieldId = null;
+    private String format;
+    public List<String> values = new ArrayList<>();
+
+    @Override
+    public Aggregation createCountAnalyseAgg() throws Exception {
+        Aggregation aggregation = null;
+        if (!CollectionUtils.isEmpty(values)) {
+            List<AggregationRange> ranges = new ArrayList<>();
+            for (String value : values) {
+                if (value.contains("-")) {
+                    String start = value.substring(0, value.indexOf("-"));
+                    String end = value.substring(value.indexOf("-") + 1);
+                    end = String.valueOf(Integer.parseInt(end) + 1);
+                    String finalEnd = end;
+                    AggregationRange range = AggregationRange.of(i -> i.from(start).to(finalEnd).key(value));
+                    ranges.add(range);
+                } else if (value.contains("以上")) {
+                    String start = value.substring(0, value.indexOf("以上"));
+                    AggregationRange range = AggregationRange.of(i -> i.from(start).key(value));
+                    ranges.add(range);
+                } else {
+                    String end = String.valueOf(Integer.parseInt(value) + 1);
+                    AggregationRange range = AggregationRange.of(i -> i.from(value).to(end).key(value));
+                    ranges.add(range);
+                }
+            }
+            aggregation = AggregationBuilders.range(i -> i.field(field).ranges(ranges));
+        }
+        return aggregation;
+    }
+
+    @Override
+    public String getField() {
+        return field;
+    }
+
+    @Override
+    public void setField(String field) {
+        this.field = field;
+    }
+
+    @Override
+    public String getValueOne() {
+        return valueOne;
+    }
+
+    @Override
+    public void setValueOne(String valueOne) {
+        this.valueOne = valueOne;
+    }
+
+    @Override
+    public String getValueTwo() {
+        return valueTwo;
+    }
+
+    @Override
+    public void setValueTwo(String valueTwo) {
+        this.valueTwo = valueTwo;
+    }
+
+    @Override
+    public Integer getTopN() {
+        return topN;
+    }
+
+    @Override
+    public void setTopN(Integer topN) {
+        this.topN = topN;
+    }
+
+    @Override
+    public String getPath() {
+        return path;
+    }
+
+    @Override
+    public void setPath(String path) {
+        this.path = path;
+    }
+
+    @Override
+    public Boolean getIfHaveChild() {
+        return ifHaveChild;
+    }
+
+    @Override
+    public void setIfHaveChild(Boolean ifHaveChild) {
+        this.ifHaveChild = ifHaveChild;
+    }
+
+    @Override
+    public String getFieldType() {
+        return fieldType;
+    }
+
+    @Override
+    public void setFieldType(String fieldType) {
+        this.fieldType = fieldType;
+    }
+
+    @Override
+    public String getFieldId() {
+        return fieldId;
+    }
+
+    @Override
+    public void setFieldId(String fieldId) {
+        this.fieldId = fieldId;
+    }
+
+    @Override
+    public String getFormat() {
+        return format;
+    }
+
+    @Override
+    public void setFormat(String format) {
+        this.format = format;
+    }
+
+    @Override
+    public List<String> getValues() {
+        return values;
+    }
+
+    @Override
+    public void setValues(List<String> values) {
+        this.values = values;
+    }
+}

src/main/java/cn/cslg/pas/factorys/EsCountAnalyseBuilderFactory/TermsCountAnalysisBuilder.java

@@ -24,6 +24,7 @@ public class TermsCountAnalysisBuilder implements IEsCountAnalysisBuilder {
     public String fieldType = null;
     public String fieldId = null;
     public List<String> values = new ArrayList<>();
+    private String format;
 
     @Override
     public Aggregation createCountAnalyseAgg() throws Exception {
@@ -38,7 +39,7 @@ public class TermsCountAnalysisBuilder implements IEsCountAnalysisBuilder {
                     .aggregations(new HashMap() {{
                         put("filter_agg", filter);
                     }}).build();
-        } else if (CollectionUtils.isEmpty(values)) {
+        } else if (!CollectionUtils.isEmpty(values)) {
             aggregation = AggregationBuilders.terms(i -> i.field(field).include(j -> j.terms(values)).size(topN));
         } else {
             aggregation = AggregationBuilders.terms(i -> i.field(field).size(topN));
@@ -117,4 +118,14 @@ public class TermsCountAnalysisBuilder implements IEsCountAnalysisBuilder {
     public void setValues(List<String> values) {
         this.values = values;
     }
+
+    @Override
+    public String getFormat() {
+        return format;
+    }
+
+    @Override
+    public void setFormat(String format) {
+        this.format = format;
+    }
 }

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

@@ -463,6 +463,14 @@ public class EsCountService {
      */
     public void getTermCountDTOS(Aggregate agg, String field, List<EsCountDetailDTO> detailDTOS) {
         List<StringTermsBucket> list = agg.sterms().buckets().array();
+        Long otherDocCount = agg.sterms().sumOtherDocCount();
+        if (otherDocCount > 0) {
+            EsCountDetailDTO dto = new EsCountDetailDTO();
+            dto.setField(field);
+            dto.setName("未知");
+            dto.setNumber(otherDocCount);
+            detailDTOS.add(dto);
+        }
         list.forEach(bucket -> {
             EsCountDetailDTO dto = new EsCountDetailDTO();
             dto.setField(field);
@@ -629,6 +637,14 @@ public class EsCountService {
      */
     public void getNestedCountDTOS(Aggregate agg, String field, List<EsCountDetailDTO> detailDTOS) {
         Aggregate termsAgg = agg.nested().aggregations().get("terms_agg");
+        Long otherDocCount = termsAgg.sterms().sumOtherDocCount();
+        if (otherDocCount > 0) {
+            EsCountDetailDTO dto = new EsCountDetailDTO();
+            dto.setField(field);
+            dto.setName("未知");
+            dto.setNumber(otherDocCount);
+            detailDTOS.add(dto);
+        }
         List<StringTermsBucket> list = termsAgg.sterms().buckets().array();
         list.forEach(bucket -> {
             EsCountDetailDTO dto = new EsCountDetailDTO();
@@ -654,7 +670,6 @@ public class EsCountService {
         }
         Integer taskId = vo.getTaskId();
         Integer projectId = vo.getProjectId();
-
         if (taskId != null) {
             if (searchCondition != null && !"".equals(searchCondition.trim())) {
                 searchCondition = "taskId = " + taskId + " AND " + searchCondition;
@@ -690,14 +705,16 @@ public class EsCountService {
         for (EsCountVO countVO : countVOS) {
             String field = countVO.getField();
             Integer topN = countVO.getTopN();
-            String condition = searchCondition;
-            String filterCondition = countVO.getFilterCondition();
+            Boolean ifHaveChild = countVO.getIfHaveChild();
+            String fieldId = countVO.getFieldId();
+            Integer fieldType = countVO.getFieldType();
+            String format = countVO.getFormat();
             String valueOne = countVO.getValueOne();
             String valueTwo = countVO.getValueTwo();
             List<String> values = countVO.getValues();
 
             IEsCountAnalysisBuilder iEsCountAnalysisBuilder = null;
-            String json = CommonService.readJsonFile("esAnalysis.json");
+            String json = CommonService.readJsonFile("esCountAnalysis.json");
             List<EsConfigVO> esConfigVOS = JSON.parseArray(json, EsConfigVO.class);
             EsConfigVO esConfigVO = esConfigVOS.stream().filter(item -> item.getField().equals(field))
                     .findFirst().orElse(null);
@@ -705,6 +722,21 @@ public class EsCountService {
             Aggregation aggregation = null;
             if (esConfigVO != null) {
                 iEsCountAnalysisBuilder = esCountAnalysisBuilderFactory.getClass(esConfigVO.getEsClass());
+                iEsCountAnalysisBuilder.setField(field);
+                iEsCountAnalysisBuilder.setValueOne(valueOne);
+                iEsCountAnalysisBuilder.setValueTwo(valueTwo);
+                iEsCountAnalysisBuilder.setValues(values);
+                iEsCountAnalysisBuilder.setFieldId(fieldId);
+                iEsCountAnalysisBuilder.setFieldType(String.valueOf(fieldType));
+                iEsCountAnalysisBuilder.setTopN(topN);
+                iEsCountAnalysisBuilder.setFormat(format);
+                iEsCountAnalysisBuilder.setIfHaveChild(ifHaveChild);
+                if (iEsCountAnalysisBuilder.getField().contains(".")) {
+                    String path = iEsCountAnalysisBuilder.getField()
+                            .substring(0, iEsCountAnalysisBuilder.getField().indexOf("."));
+                    iEsCountAnalysisBuilder.setPath(path);
+                }
+                aggregation = iEsCountAnalysisBuilder.createCountAnalyseAgg();
                 if (StringUtils.isNotEmpty(valueOne) || StringUtils.isNotEmpty(valueTwo)) {
 
                 } else if (!CollectionUtils.isEmpty(values)) {
@@ -715,17 +747,82 @@ public class EsCountService {
             }
             if (query != null) {
                 Query finalQuery = query;
+                Aggregation finalAggregation = aggregation;
                 Aggregation filtersAgg = new Aggregation.Builder().filters(new FiltersAggregation.Builder()
                         .filters(i -> i.array(Arrays.asList(finalQuery))).build())
                         .aggregations(new HashMap() {{
-                            put("filters_agg", aggregation);
+                            put("filters_agg", finalAggregation);
                         }}).build();
                 builder.aggregations("Agg", filtersAgg);
             } else {
                 builder.aggregations("Agg", aggregation);
             }
             SearchResponse<Patent> response = client.search(builder.build(), Patent.class);
+            Aggregate agg = response.aggregations().get("Agg");
+            if (query != null) {
+                String finalSearchCondition = searchCondition;
+                if (StringUtils.isNotEmpty(field)) {
+                    List<FiltersBucket> filtersBuckets = agg.filters().buckets().array();
+                    if (dateList.contains(field)) {
+                        filtersBuckets.forEach(filtersBucket -> {
+                            this.getFiltersCountDTO(filtersBucket, finalSearchCondition, detailDTOS);
+                            Aggregate filtersAgg = filtersBucket.aggregations().get("filters_agg");
+                            this.getDateCountDTOS(filtersAgg, field, topN, detailDTOS);
+                        });
+                    } else if (nestedList.contains(field)) {
+                        filtersBuckets.forEach(filtersBucket -> {
+                            this.getFiltersCountDTO(filtersBucket, finalSearchCondition, detailDTOS);
+                            Aggregate filtersAgg = filtersBucket.aggregations().get("filters_agg");
+                            this.getNestedCountDTOS(filtersAgg, field, detailDTOS);
+                        });
+                    } else if (childList.contains(field)) {
+                        filtersBuckets.forEach(filtersBucket -> {
+                            this.getFiltersCountDTO(filtersBucket, finalSearchCondition, detailDTOS);
+                            Aggregate filtersAgg = filtersBucket.aggregations().get("filters_agg");
+                            this.getChildCountDTOS(filtersAgg, field, detailDTOS);
+                        });
+                    } else {
+                        filtersBuckets.forEach(filtersBucket -> {
+                            this.getFiltersCountDTO(filtersBucket, finalSearchCondition, detailDTOS);
+                            Aggregate filtersAgg = filtersBucket.aggregations().get("filters_agg");
+                            this.getTermCountDTOS(filtersAgg, field, detailDTOS);
+                        });
+                    }
+                } else {
+                    this.getFilterCountDTO(agg, finalSearchCondition, detailDTOS);
+                }
+            } else {
+                if (dateList.contains(field)) {
+                    this.getDateAnalysisDTOS(agg, field, topN, detailDTOS);
+                } else if (nestedList.contains(field)) {
+                    this.getNestedCountDTOS(agg, field, detailDTOS);
+                } else if (childList.contains(field)) {
+                    this.getChildAnalysisDTOS(agg, field, detailDTOS);
+                } else if (numberList.contains(field)) {
+                    this.getNumberAnalysisDTOS(agg, field, detailDTOS);
+                } else {
+                    this.getTermCountDTOS(agg, field, detailDTOS);
+                }
+            }
         }
-        return null;
+        esCountDTO.setDetailDTOS(detailDTOS);
+        return esCountDTO;
+    }
+
+    public void getTermCountAnalysis(Aggregate agg, String field,String value,List<String> values, List<EsCountDetailDTO> detailDTOS) {
+        List<StringTermsBucket> list = agg.sterms().buckets().array();
+        list.forEach(bucket -> {
+            EsCountDetailDTO dto = new EsCountDetailDTO();
+            dto.setField(field);
+            Aggregate aggregate = bucket.aggregations().get("filter_agg");
+            dto.setName(bucket.key().stringValue());
+            dto.setNumber(bucket.docCount());
+            if (aggregate != null) {
+                dto.setNumber(aggregate.filter().docCount());
+            }
+            if (dto.getNumber() > 0) {
+                detailDTOS.add(dto);
+            }
+        });
     }
 }

src/main/resources/jsons/esCountAnalysis.json

@@ -0,0 +1,590 @@
+[
+  {
+    "name": "IPC分类号一级",
+    "type": "String",
+    "value": "ipcLevel1",
+    "field": "IC",
+    "esField": "mipc.level1",
+    "esClass": "termsCountAnalysisBuilder",
+    "ifSearch": "false",
+    "ifGroup": "false",
+    "ifShow": "true",
+    "ifAsCondition": "true"
+  },
+  {
+    "name": "IPC分类号二级",
+    "type": "String",
+    "value": "ipcLevel2",
+    "field": "IC2",
+    "esField": "mipc.level2",
+    "esClass": "termsCountAnalysisBuilder",
+    "ifSearch": "false",
+    "ifGroup": "false",
+    "ifShow": "true",
+    "ifAsCondition": "true"
+  },
+  {
+    "name": "IPC分类号三级",
+    "type": "String",
+    "value": "ipcLevel3",
+    "field": "IC3",
+    "esField": "mipc.level3",
+    "esClass": "termsCountAnalysisBuilder",
+    "ifSearch": "false",
+    "ifGroup": "false",
+    "ifShow": "true",
+    "ifAsCondition": "true"
+  },
+  {
+    "name": "IPC分类号四级",
+    "type": "String",
+    "value": "ipcLevel4",
+    "field": "IC4",
+    "esField": "mipc.level4",
+    "esClass": "termsCountAnalysisBuilder",
+    "ifSearch": "false",
+    "ifGroup": "false",
+    "ifShow": "true",
+    "ifAsCondition": "true"
+  },
+  {
+    "name": "IPC分类号五级",
+    "type": "String",
+    "value": "ipcLevel5",
+    "field": "IC5",
+    "esField": "mipc.level5",
+    "esClass": "termsCountAnalysisBuilder",
+    "ifSearch": "false",
+    "ifGroup": "false",
+    "ifShow": "true",
+    "ifAsCondition": "true"
+  },
+  {
+    "name": "CPC分类号一级",
+    "type": "String",
+    "value": "cpcLevel1",
+    "field": "CPC",
+    "esField": "mcpc.level1",
+    "esClass": "termsCountAnalysisBuilder",
+    "ifSearch": "false",
+    "ifGroup": "false",
+    "ifShow": "true",
+    "ifAsCondition": "true"
+  },
+  {
+    "name": "CPC分类号二级",
+    "type": "String",
+    "value": "cpcLevel2",
+    "field": "CPC2",
+    "esField": "mcpc.level2",
+    "esClass": "termsCountAnalysisBuilder",
+    "ifSearch": "false",
+    "ifGroup": "false",
+    "ifShow": "true",
+    "ifAsCondition": "true"
+  },
+  {
+    "name": "CPC分类号三级",
+    "type": "String",
+    "value": "cpcLevel3",
+    "field": "CPC3",
+    "esField": "mcpc.level3",
+    "esClass": "termsCountAnalysisBuilder",
+    "ifSearch": "false",
+    "ifGroup": "false",
+    "ifShow": "true",
+    "ifAsCondition": "true"
+  },
+  {
+    "name": "CPC分类号四级",
+    "type": "String",
+    "value": "cpcLevel4",
+    "field": "CPC4",
+    "esField": "mcpc.level4",
+    "esClass": "termsCountAnalysisBuilder",
+    "ifSearch": "false",
+    "ifGroup": "false",
+    "ifShow": "true",
+    "ifAsCondition": "true"
+  },
+  {
+    "name": "CPC分类号五级",
+    "type": "String",
+    "value": "cpcLevel5",
+    "field": "CPC5",
+    "esField": "mcpc.level5",
+    "esClass": "termsCountAnalysisBuilder",
+    "ifSearch": "false",
+    "ifGroup": "false",
+    "ifShow": "true",
+    "ifAsCondition": "true"
+  },
+  {
+    "name": "UPC分类号一级",
+    "type": "String",
+    "value": "upcLevel1",
+    "field": "UPC",
+    "esField": "mupc.level1",
+    "esClass": "termsCountAnalysisBuilder",
+    "ifSearch": "false",
+    "ifGroup": "false",
+    "ifShow": "true",
+    "ifAsCondition": "true"
+  },
+  {
+    "name": "UPC分类号二级",
+    "type": "String",
+    "value": "upcLevel2",
+    "field": "UPC2",
+    "esField": "mupc.level2",
+    "esClass": "termsCountAnalysisBuilder",
+    "ifSearch": "false",
+    "ifGroup": "false",
+    "ifShow": "true",
+    "ifAsCondition": "true"
+  },
+  {
+    "name": "UPC分类号三级",
+    "type": "String",
+    "value": "upcLevel3",
+    "field": "UPC3",
+    "esField": "mupc.level3",
+    "esClass": "termsCountAnalysisBuilder",
+    "ifSearch": "false",
+    "ifGroup": "false",
+    "ifShow": "true",
+    "ifAsCondition": "true"
+  },
+  {
+    "name": "LOC分类号一级",
+    "type": "String",
+    "value": "locLevel1",
+    "field": "LOC",
+    "esField": "mloc.level1",
+    "esClass": "termsCountAnalysisBuilder",
+    "ifSearch": "false",
+    "ifGroup": "false",
+    "ifShow": "true",
+    "ifAsCondition": "true"
+  },
+  {
+    "name": "LOC分类号二级",
+    "type": "String",
+    "value": "locLevel2",
+    "field": "LOC2",
+    "esField": "mloc.level2",
+    "esClass": "termsCountAnalysisBuilder",
+    "ifSearch": "false",
+    "ifGroup": "false",
+    "ifShow": "true",
+    "ifAsCondition": "true"
+  },
+  {
+    "name": "LOC分类号三级",
+    "type": "String",
+    "value": "locLevel3",
+    "field": "LOC3",
+    "esField": "mloc.level3",
+    "esClass": "termsCountAnalysisBuilder",
+    "ifSearch": "false",
+    "ifGroup": "false",
+    "ifShow": "true",
+    "ifAsCondition": "true"
+  },
+  {
+    "name": "申请人",
+    "type": "String",
+    "value": "applicant",
+    "field": "PA",
+    "esField": "applicant.name.key",
+    "esClass": "nestedCountAnalysisBuilder",
+    "ifSearch": "false",
+    "ifGroup": "false",
+    "ifShow": "true",
+    "ifAsCondition": "true"
+  },
+  {
+    "name": "标准申请人",
+    "type": "String",
+    "value": "standerApplicant",
+    "field": "SAT",
+    "esField": "stander_applicant.name.key",
+    "esClass": "nestedCountAnalysisBuilder",
+    "ifSearch": "false",
+    "ifGroup": "false",
+    "ifShow": "true",
+    "ifAsCondition": "true"
+  },
+  {
+    "name": "合并申请人",
+    "type": "String",
+    "value": "mergeApplicant",
+    "field": "MAT",
+    "esField": "merge_applicant.name.key",
+    "esClass": "nestedCountAnalysisBuilder",
+    "ifSearch": "false",
+    "ifGroup": "false",
+    "ifShow": "true",
+    "ifAsCondition": "true"
+  },
+  {
+    "name": "权利人",
+    "type": "String",
+    "value": "rightHolder",
+    "field": "PE",
+    "esField": "right_holder.name.key",
+    "esClass": "nestedCountAnalysisBuilder",
+    "ifSearch": "false",
+    "ifGroup": "false",
+    "ifShow": "true",
+    "ifAsCondition": "true"
+  },
+  {
+    "name": "标准权利人",
+    "type": "String",
+    "value": "standerRightHolder",
+    "field": "SRH",
+    "esField": "stander_right_holder.name.key",
+    "esClass": "nestedCountAnalysisBuilder",
+    "ifSearch": "false",
+    "ifGroup": "false",
+    "ifShow": "true",
+    "ifAsCondition": "true"
+  },
+  {
+    "name": "合并权利人",
+    "type": "String",
+    "value": "mergeRightHolder",
+    "field": "MRH",
+    "esField": "merge_right_holder.name.key",
+    "esClass": "nestedCountAnalysisBuilder",
+    "ifSearch": "false",
+    "ifGroup": "false",
+    "ifShow": "true",
+    "ifAsCondition": "true"
+  },
+  {
+    "name": "发明人",
+    "type": "String",
+    "value": "inventor",
+    "field": "IN",
+    "esField": "inventor.name.key",
+    "esClass": "nestedCountAnalysisBuilder",
+    "ifSearch": "false",
+    "ifGroup": "false",
+    "ifShow": "true",
+    "ifAsCondition": "true"
+  },
+  {
+    "name": "代理机构",
+    "type": "String",
+    "value": "agency",
+    "field": "AGN",
+    "esField": "agency",
+    "esClass": "termsCountAnalysisBuilder",
+    "ifSearch": "false",
+    "ifGroup": "false",
+    "ifShow": "true",
+    "ifAsCondition": "true"
+  },
+  {
+    "name": "代理人名称",
+    "type": "String",
+    "value": "agent",
+    "field": "PT",
+    "esField": "agent.key",
+    "esClass": "termsCountAnalysisBuilder",
+    "ifSearch": "false",
+    "ifGroup": "false",
+    "ifShow": "true",
+    "ifAsCondition": "true"
+  },
+  {
+    "name": "公开日",
+    "type": "Date",
+    "value": "publicDate",
+    "field": "PD",
+    "esField": "public_date",
+    "esClass": "dateCountAnalyssBuilder",
+    "ifSearch": "false",
+    "ifGroup": "false",
+    "ifShow": "true",
+    "ifAsCondition": "true"
+  },
+  {
+    "name": "申请日",
+    "type": "String",
+    "value": "appDate",
+    "field": "AD",
+    "esField": "app_date",
+    "esClass": "dateCountAnalyssBuilder",
+    "ifSearch": "false",
+    "ifGroup": "false",
+    "ifShow": "true",
+    "ifAsCondition": "true"
+  },
+  {
+    "name": "授权日",
+    "type": "String",
+    "value": "grantDate",
+    "field": "GD",
+    "esField": "grant_date",
+    "esClass": "dateCountAnalyssBuilder",
+    "ifSearch": "false",
+    "ifGroup": "false",
+    "ifShow": "true",
+    "ifAsCondition": "true"
+  },
+  {
+    "name": "申请国家(受理局)",
+    "type": "String",
+    "value": "appCountry",
+    "field": "CO",
+    "esField": "app_country",
+    "esClass": "termsCountAnalysisBuilder",
+    "ifSearch": "false",
+    "ifGroup": "false",
+    "ifShow": "false",
+    "ifAsCondition": "true"
+  },
+  {
+    "name": "申请人国家",
+    "type": "String",
+    "value": "appCountry",
+    "field": "DZ",
+    "esField": "applicant_addr.country",
+    "esClass": "termsCountAnalysisBuilder",
+    "ifSearch": "false",
+    "ifGroup": "false",
+    "ifShow": "false",
+    "ifAsCondition": "true"
+  },
+  {
+    "name": "申请人省份",
+    "type": "String",
+    "value": "appProvince",
+    "field": "ADP",
+    "esField": "applicant_addr.province",
+    "esClass": "termsCountAnalysisBuilder",
+    "ifSearch": "false",
+    "ifGroup": "false",
+    "ifShow": "false",
+    "ifAsCondition": "true"
+  },
+  {
+    "name": "申请人市区",
+    "type": "String",
+    "value": "appCity",
+    "field": "ADC",
+    "esField": "applicant_addr.city",
+    "esClass": "termsCountAnalysisBuilder",
+    "ifSearch": "false",
+    "ifGroup": "false",
+    "ifShow": "false",
+    "ifAsCondition": "true"
+  },
+  {
+    "name": "权利人国家",
+    "type": "String",
+    "value": "rightCountry",
+    "field": "rightCountry",
+    "esField": "right_holder_addr.country",
+    "esClass": "termsCountAnalysisBuilder",
+    "ifSearch": "false",
+    "ifGroup": "false",
+    "ifShow": "false",
+    "ifAsCondition": "true"
+  },
+  {
+    "name": "权利人省份",
+    "type": "String",
+    "value": "rightProvince",
+    "field": "rightProvince",
+    "esField": "right_holder_addr.province",
+    "esClass": "termsCountAnalysisBuilder",
+    "ifSearch": "false",
+    "ifGroup": "false",
+    "ifShow": "false",
+    "ifAsCondition": "true"
+  },
+  {
+    "name": "权利人市区",
+    "type": "String",
+    "value": "rightCity",
+    "field": "rightCity",
+    "esField": "right_holder_addr.city",
+    "esClass": "termsCountAnalysisBuilder",
+    "ifSearch": "false",
+    "ifGroup": "false",
+    "ifShow": "false",
+    "ifAsCondition": "true"
+  },
+  {
+    "name": "优先权国家",
+    "type": "String",
+    "value": "priorityCountry",
+    "field": "PC",
+    "esField": "priorities.prioritycountry",
+    "esClass": "termsCountAnalysisBuilder",
+    "ifSearch": "false",
+    "ifGroup": "false",
+    "ifShow": "false",
+    "ifAsCondition": "true"
+  },
+  {
+    "name": "引用专利数量",
+    "type": "Integer",
+    "value": "quotePatentNoNum",
+    "field": "QPN",
+    "esField": "quote_patent_no_num",
+    "esClass": "rangeCountAnalysisBuilder",
+    "ifSearch": "false",
+    "ifGroup": "false",
+    "ifShow": "true",
+    "ifAsCondition": "true"
+  },
+  {
+    "name": "被引用专利数量",
+    "type": "Integer",
+    "value": "quotedPatentNoNum",
+    "field": "QDPN",
+    "esField": "quoted_patent_no_num",
+    "esClass": "rangeCountAnalysisBuilder",
+    "ifSearch": "false",
+    "ifGroup": "false",
+    "ifShow": "true",
+    "ifAsCondition": "true"
+  },
+  {
+    "name": "简单同族数量",
+    "type": "Integer",
+    "value": "simpleFamilyNum",
+    "field": "SFN",
+    "esField": "simple_family_num",
+    "esClass": "rangeCountAnalysisBuilder",
+    "ifSearch": "false",
+    "ifGroup": "false",
+    "ifShow": "true",
+    "ifAsCondition": "true"
+  },
+  {
+    "name": "inpadoc同族数量",
+    "type": "Integer",
+    "value": "inpadocFamilyNum",
+    "field": "IFN",
+    "esField": "inpadoc_family_num",
+    "esClass": "rangeCountAnalysisBuilder",
+    "ifSearch": "false",
+    "ifGroup": "false",
+    "ifShow": "true",
+    "ifAsCondition": "true"
+  },
+  {
+    "name": "扩展同族数量",
+    "type": "Integer",
+    "value": "patsnapFamilyNum",
+    "field": "PFN",
+    "esField": "patsnap_family_num",
+    "esClass": "rangeCountAnalysisBuilder",
+    "ifSearch": "false",
+    "ifGroup": "false",
+    "ifShow": "true",
+    "ifAsCondition": "true"
+  },
+  {
+    "name": "专利状态",
+    "type": "String",
+    "value": "simpleStatus",
+    "field": "SS",
+    "esField": "simple_status",
+    "esClass": "termsCountAnalysisBuilder",
+    "ifSearch": "false",
+    "ifGroup": "false",
+    "ifShow": "true",
+    "ifAsCondition": "true"
+  },
+  {
+    "name": "专利类型",
+    "type": "String",
+    "value": "patentType",
+    "field": "PT",
+    "esField": "patent_type",
+    "esClass": "termsCountAnalysisBuilder",
+    "ifSearch": "false",
+    "ifGroup": "false",
+    "ifShow": "true",
+    "ifAsCondition": "true"
+  },
+  {
+    "name": "法律状态",
+    "type": "String",
+    "value": "legalStatus",
+    "field": "LG",
+    "esField": "legal_status",
+    "esClass": "termsCountAnalysisBuilder",
+    "ifSearch": "false",
+    "ifGroup": "false",
+    "ifShow": "true",
+    "ifAsCondition": "true"
+  },
+  {
+    "name": "自定义栏位id",
+    "type": "String",
+    "value": "field",
+    "field": "field",
+    "esField": "custom_field.field",
+    "esClass": "childAnalysisBuilder",
+    "ifSearch": "false",
+    "ifGroup": "false",
+    "ifShow": "true",
+    "ifAsCondition": "true"
+  },
+  {
+    "name": "自定义栏位值",
+    "type": "String",
+    "value": "fieldValue",
+    "field": "fieldValue",
+    "esField": "custom_field.field_value.raw",
+    "esClass": "childAnalysisBuilder",
+    "ifSearch": "false",
+    "ifGroup": "false",
+    "ifShow": "true",
+    "ifAsCondition": "true"
+  },
+  {
+    "name": "自定义栏位统计值",
+    "type": "String",
+    "value": "statsValue",
+    "field": "statsValue",
+    "esField": "custom_field.stats_value.raw",
+    "esClass": "childAnalysisBuilder",
+    "ifSearch": "false",
+    "ifGroup": "false",
+    "ifShow": "true",
+    "ifAsCondition": "true"
+  },
+  {
+    "name": "业务任务",
+    "type": "String",
+    "value": "taskId",
+    "field": "taskId",
+    "esField": "project_task.task_id",
+    "esClass": "projectTaskQueryBuilder",
+    "ifSearch": "false",
+    "ifGroup": "false",
+    "ifShow": "false",
+    "ifAsCondition": "true"
+  },
+  {
+    "name": "子文档号",
+    "type": "String",
+    "value": "projectId",
+    "field": "projectId",
+    "esField": "project_id",
+    "esClass": "childQueryBuilder",
+    "ifSearch": "false",
+    "ifGroup": "false",
+    "ifShow": "false",
+    "ifAsCondition": "true"
+  }
+]