Merge remote-tracking branch 'origin/master'

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

@@ -0,0 +1,272 @@
+package cn.cslg.pas.factorys.EsCountAnalyseBuilderFactory;
+
+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 PrioritiesCountAnalysisBuilder 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)) {
+            String end = String.valueOf(Integer.parseInt(valueTwo) + 1);
+            Query query = QueryBuilders.range(j -> j.field(field).from(valueOne).to(end).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 halfYearAgg = AggregationBuilders.dateHistogram(i -> i.field(field).format("yyyy-MM").calendarInterval(CalendarInterval.Month));
+                aggregation = new Aggregation.Builder().dateHistogram(new DateHistogramAggregation.Builder()
+                        .field(field).format("yyyy")
+                        .calendarInterval(CalendarInterval.Year).build())
+                        .aggregations(new HashMap() {{
+                            put("halfYearAgg", halfYearAgg);
+                        }}).build();
+            } 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));
+
+        }
+
+        Aggregation finalAggregation = aggregation;
+        Aggregation Agg = new Aggregation.Builder().nested(new NestedAggregation.Builder().
+                path(path).build())
+                .aggregations(new HashMap() {{
+                    put("terms_agg", finalAggregation);
+                }}).build();
+        return Agg;
+    }
+
+    public String getField() {
+        return field;
+    }
+
+    public void setField(String field) {
+        this.field = field;
+    }
+
+    public String getValueOne() {
+        return valueOne;
+    }
+
+    public void setValueOne(String valueOne) {
+        this.valueOne = valueOne;
+    }
+
+    public String getValueTwo() {
+        return valueTwo;
+    }
+
+    public void setValueTwo(String valueTwo) {
+        this.valueTwo = valueTwo;
+    }
+
+    public Integer getTopN() {
+        return topN;
+    }
+
+    public void setTopN(Integer topN) {
+        this.topN = topN;
+    }
+
+    public String getPath() {
+        return path;
+    }
+
+    public void setPath(String path) {
+        this.path = path;
+    }
+
+    public Boolean getIfHaveChild() {
+        return ifHaveChild;
+    }
+
+    public void setIfHaveChild(Boolean ifHaveChild) {
+        this.ifHaveChild = ifHaveChild;
+    }
+
+    public String getFieldType() {
+        return fieldType;
+    }
+
+    public void setFieldType(String fieldType) {
+        this.fieldType = fieldType;
+    }
+
+    public String getFieldId() {
+        return fieldId;
+    }
+
+    public void setFieldId(String fieldId) {
+        this.fieldId = fieldId;
+    }
+
+    public String getFormat() {
+        return format;
+    }
+
+    public void setFormat(String format) {
+        this.format = format;
+    }
+
+    public List<String> getValues() {
+        return values;
+    }
+
+    public void setValues(List<String> values) {
+        this.values = values;
+    }
+}

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

@@ -38,9 +38,10 @@ import java.util.stream.Collectors;
 @RequiredArgsConstructor(onConstructor_ = {@Lazy})
 public class EsCountService {
     private final List<String> childList = Arrays.asList("field");
-    private final List<String> nestedList = Arrays.asList("PA", "IN", "PE", "SAT", "MAT", "SRH", "MRH", "MIN");
+    private final List<String> nestedList = Arrays.asList("PA", "IN", "PE", "SAT", "MAT", "SRH", "MRH", "MIN","PRCO");
     private final List<String> dateList = Arrays.asList("PD", "AD", "GD");
     private final List<String> numberList = Arrays.asList("QPN", "QDPN", "SFN", "IFN", "PFN");
+    private final List<String> nestDateList = Arrays.asList("PRD");
 
 
     private final ElasticsearchClient client;
@@ -153,7 +154,6 @@ public class EsCountService {
             }
         }
 
-
         if (!CollectionUtils.isEmpty(customFields)) {
             searchCondition = esService.parseCustomField(customFields);
         }
@@ -226,6 +226,24 @@ public class EsCountService {
                                 esCountDTO.setAllNumber(filtersAgg.nested().docCount());
                             }
                         });
+                    } else if (nestDateList.contains(field)) {
+                        if (CollectionUtils.isEmpty(values)) {
+                            filtersBuckets.forEach(filtersBucket -> {
+                                Aggregate filtersAgg = filtersBucket.aggregations().get("filters_agg");
+                                Aggregate termsAgg = filtersAgg.nested().aggregations().get("terms_agg");
+                                try {
+                                    this.getDateCountDTOS(termsAgg, field, topN, format, detailDTOS, esCountDTO);
+                                } catch (ParseException e) {
+                                    e.printStackTrace();
+                                }
+                            });
+                        } else {
+                            filtersBuckets.forEach(filtersBucket -> {
+                                Aggregate filtersAgg = filtersBucket.aggregations().get("filters_agg");
+                                Aggregate termsAgg = filtersAgg.nested().aggregations().get("terms_agg");
+                                this.getDateAnalysisDTOS(termsAgg, field, topN, detailDTOS, esCountDTO, firstName, map, values);
+                            });
+                        }
                     } else if (childList.contains(field)) {
                         if (CollectionUtils.isEmpty(values)) {
                             Integer finalFieldType = fieldType;
@@ -478,9 +496,13 @@ public class EsCountService {
         EsCountDetailDTO countDTO = new EsCountDetailDTO();
         countDTO.setField(field);
         countDTO.setName("其他");
-        countDTO.setNumber(agg.sterms().sumOtherDocCount());
         countDTO.setTopN(topN);
-        detailDTOS.add(countDTO);
+        Long count = agg.sterms().sumOtherDocCount();
+        if (count > 0) {
+            countDTO.setNumber(count);
+            detailDTOS.add(countDTO);
+        }
+
         List<StringTermsBucket> list = agg.sterms().buckets().array();
         list.forEach(bucket -> {
             EsCountDetailDTO dto = new EsCountDetailDTO();
@@ -933,9 +955,13 @@ public class EsCountService {
         EsCountDetailDTO countDTO = new EsCountDetailDTO();
         countDTO.setField(field);
         countDTO.setName("其他");
-        countDTO.setNumber(termsAgg.sterms().sumOtherDocCount());
         countDTO.setTopN(topN);
-        countDetailDTOS.add(countDTO);
+        Long count = termsAgg.sterms().sumOtherDocCount();
+        if (count > 0) {
+            countDTO.setNumber(count);
+            countDetailDTOS.add(countDTO);
+        }
+
         List<StringTermsBucket> list = termsAgg.sterms().buckets().array();
         list.forEach(bucket -> {
             EsCountDetailDTO dto = new EsCountDetailDTO();

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

@@ -378,14 +378,22 @@ public class EsPatentService {
                     kinDetailVO.setAppNo(familyPatent.getAppNo());
                     kinDetailVO.setPublicNo(familyPatent.getPublicNo());
                     kinDetailVO.setGrantNo(familyPatent.getGrantNo());
-                    PatentKinDTO kinDTO = this.selectPatentKindDetail(kinDetailVO, patentNo)
-                            .stream().findFirst().orElse(null);
-                    if (kinDTO != null) {
-                        kinDTOS.add(kinDTO);
+                    if (StringUtils.isNotEmpty(patentNo)) {
+                        PatentKinDTO kinDTO = this.selectPatentKindDetail(kinDetailVO, patentNo)
+                                .stream().findFirst().orElse(null);
+                        if (kinDTO != null) {
+                            kinDTOS.add(kinDTO);
+                        }
+                        break;
+                    } else {
+                        PatentKinDTO kinDTO = this.selectPatentKindDetail(kinDetailVO, patentNo)
+                                .stream().findFirst().orElse(null);
+                        if (kinDTO != null) {
+                            kinDTOS.add(kinDTO);
+                        }
                     }
                 }
             }
-
         }
         return kinDTOS;
     }
@@ -407,7 +415,7 @@ public class EsPatentService {
         if (StringUtils.isNotEmpty(patentNo)) {
             String str = "*";
             String s = str.concat(patentNo).concat("*");
-            Query query = QueryBuilders.wildcard(i -> i.field(patentNo).value(s));
+            Query query = QueryBuilders.wildcard(i -> i.field("patent_no.keyword").value(s));
             bool = QueryBuilders.bool(i -> i.should(q1, q2).must(query));
         } else {
             bool = QueryBuilders.bool(i -> i.should(q1, q2));

src/main/resources/jsons/esCountAnalysis.json

@@ -413,7 +413,7 @@
     "value": "priorityCountry",
     "field": "PRCO",
     "esField": "priorities.prioritycountry",
-    "esClass": "termsCountAnalysisBuilder",
+    "esClass": "nestedCountAnalysisBuilder",
     "ifSearch": "false",
     "ifGroup": "false",
     "ifShow": "false",
@@ -421,11 +421,11 @@
   },
   {
     "name": "优先权日",
-    "type": "String",
+    "type": "DateTime",
     "value": "priorityDate",
     "field": "PRD",
     "esField": "priorities.prioritydate",
-    "esClass": "termsCountAnalysisBuilder",
+    "esClass": "prioritiesCountAnalysisBuilder",
     "ifSearch": "false",
     "ifGroup": "false",
     "ifShow": "false",