View Javadoc
1   /*
2    * Copyright 2012-2021 CodeLibs Project and the Others.
3    *
4    * Licensed under the Apache License, Version 2.0 (the "License");
5    * you may not use this file except in compliance with the License.
6    * You may obtain a copy of the License at
7    *
8    *     http://www.apache.org/licenses/LICENSE-2.0
9    *
10   * Unless required by applicable law or agreed to in writing, software
11   * distributed under the License is distributed on an "AS IS" BASIS,
12   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND,
13   * either express or implied. See the License for the specific language
14   * governing permissions and limitations under the License.
15   */
16  package org.codelibs.fess.es.log.cbean.ca.bs;
17  
18  import org.codelibs.fesen.search.aggregations.bucket.filter.FilterAggregationBuilder;
19  import org.codelibs.fesen.search.aggregations.bucket.global.GlobalAggregationBuilder;
20  import org.codelibs.fesen.search.aggregations.bucket.histogram.DateHistogramAggregationBuilder;
21  import org.codelibs.fesen.search.aggregations.bucket.missing.MissingAggregationBuilder;
22  import org.codelibs.fesen.search.aggregations.bucket.range.DateRangeAggregationBuilder;
23  import org.codelibs.fesen.search.aggregations.bucket.sampler.SamplerAggregationBuilder;
24  import org.codelibs.fesen.search.aggregations.metrics.CardinalityAggregationBuilder;
25  import org.codelibs.fesen.search.aggregations.metrics.ScriptedMetricAggregationBuilder;
26  import org.codelibs.fesen.search.aggregations.metrics.TopHitsAggregationBuilder;
27  import org.codelibs.fesen.search.aggregations.metrics.ValueCountAggregationBuilder;
28  import org.codelibs.fess.es.log.allcommon.EsAbstractConditionAggregation;
29  import org.codelibs.fess.es.log.allcommon.EsAbstractConditionQuery;
30  import org.codelibs.fess.es.log.cbean.ca.UserInfoCA;
31  import org.codelibs.fess.es.log.cbean.cq.UserInfoCQ;
32  import org.codelibs.fess.es.log.cbean.cq.bs.BsUserInfoCQ;
33  
34  /**
35   * @author ESFlute (using FreeGen)
36   */
37  public abstract class BsUserInfoCA extends EsAbstractConditionAggregation {
38  
39      // ===================================================================================
40      //                                                                     Aggregation Set
41      //                                                                           =========
42  
43      public void filter(String name, EsAbstractConditionQuery.OperatorCall<BsUserInfoCQ> queryLambda,
44              ConditionOptionCall<FilterAggregationBuilder> opLambda, OperatorCall<BsUserInfoCA> aggsLambda) {
45          UserInfoCQ cq = new UserInfoCQ();
46          if (queryLambda != null) {
47              queryLambda.callback(cq);
48          }
49          FilterAggregationBuilder builder = regFilterA(name, cq.getQuery());
50          if (opLambda != null) {
51              opLambda.callback(builder);
52          }
53          if (aggsLambda != null) {
54              UserInfoCA ca = new UserInfoCA();
55              aggsLambda.callback(ca);
56              ca.getAggregationBuilderList().forEach(builder::subAggregation);
57          }
58      }
59  
60      public void global(String name, ConditionOptionCall<GlobalAggregationBuilder> opLambda, OperatorCall<BsUserInfoCA> aggsLambda) {
61          GlobalAggregationBuilder builder = regGlobalA(name);
62          if (opLambda != null) {
63              opLambda.callback(builder);
64          }
65          if (aggsLambda != null) {
66              UserInfoCA ca = new UserInfoCA();
67              aggsLambda.callback(ca);
68              ca.getAggregationBuilderList().forEach(builder::subAggregation);
69          }
70      }
71  
72      public void sampler(String name, ConditionOptionCall<SamplerAggregationBuilder> opLambda, OperatorCall<BsUserInfoCA> aggsLambda) {
73          SamplerAggregationBuilder builder = regSamplerA(name);
74          if (opLambda != null) {
75              opLambda.callback(builder);
76          }
77          if (aggsLambda != null) {
78              UserInfoCA ca = new UserInfoCA();
79              aggsLambda.callback(ca);
80              ca.getAggregationBuilderList().forEach(builder::subAggregation);
81          }
82      }
83  
84      public void scriptedMetric(String name, ConditionOptionCall<ScriptedMetricAggregationBuilder> opLambda) {
85          ScriptedMetricAggregationBuilder builder = regScriptedMetricA(name);
86          if (opLambda != null) {
87              opLambda.callback(builder);
88          }
89      }
90  
91      public void topHits(String name, ConditionOptionCall<TopHitsAggregationBuilder> opLambda) {
92          TopHitsAggregationBuilder builder = regTopHitsA(name);
93          if (opLambda != null) {
94              opLambda.callback(builder);
95          }
96      }
97  
98      public void setCreatedAt_DateRange() {
99          setCreatedAt_DateRange(null);
100     }
101 
102     public void setCreatedAt_DateRange(ConditionOptionCall<DateRangeAggregationBuilder> opLambda) {
103         setCreatedAt_DateRange("createdAt", opLambda, null);
104     }
105 
106     public void setCreatedAt_DateRange(ConditionOptionCall<DateRangeAggregationBuilder> opLambda, OperatorCall<BsUserInfoCA> aggsLambda) {
107         setCreatedAt_DateRange("createdAt", opLambda, aggsLambda);
108     }
109 
110     public void setCreatedAt_DateRange(String name, ConditionOptionCall<DateRangeAggregationBuilder> opLambda,
111             OperatorCall<BsUserInfoCA> aggsLambda) {
112         DateRangeAggregationBuilder builder = regDateRangeA(name, "createdAt");
113         if (opLambda != null) {
114             opLambda.callback(builder);
115         }
116         if (aggsLambda != null) {
117             UserInfoCA ca = new UserInfoCA();
118             aggsLambda.callback(ca);
119             ca.getAggregationBuilderList().forEach(builder::subAggregation);
120         }
121     }
122 
123     public void setCreatedAt_DateHistogram() {
124         setCreatedAt_DateHistogram(null);
125     }
126 
127     public void setCreatedAt_DateHistogram(ConditionOptionCall<DateHistogramAggregationBuilder> opLambda) {
128         setCreatedAt_DateHistogram("createdAt", opLambda, null);
129     }
130 
131     public void setCreatedAt_DateHistogram(ConditionOptionCall<DateHistogramAggregationBuilder> opLambda,
132             OperatorCall<BsUserInfoCA> aggsLambda) {
133         setCreatedAt_DateHistogram("createdAt", opLambda, aggsLambda);
134     }
135 
136     public void setCreatedAt_DateHistogram(String name, ConditionOptionCall<DateHistogramAggregationBuilder> opLambda,
137             OperatorCall<BsUserInfoCA> aggsLambda) {
138         DateHistogramAggregationBuilder builder = regDateHistogramA(name, "createdAt");
139         if (opLambda != null) {
140             opLambda.callback(builder);
141         }
142         if (aggsLambda != null) {
143             UserInfoCA ca = new UserInfoCA();
144             aggsLambda.callback(ca);
145             ca.getAggregationBuilderList().forEach(builder::subAggregation);
146         }
147     }
148 
149     public void setCreatedAt_Count() {
150         setCreatedAt_Count(null);
151     }
152 
153     public void setCreatedAt_Count(ConditionOptionCall<ValueCountAggregationBuilder> opLambda) {
154         setCreatedAt_Count("createdAt", opLambda);
155     }
156 
157     public void setCreatedAt_Count(String name, ConditionOptionCall<ValueCountAggregationBuilder> opLambda) {
158         ValueCountAggregationBuilder builder = regCountA(name, "createdAt");
159         if (opLambda != null) {
160             opLambda.callback(builder);
161         }
162     }
163 
164     public void setCreatedAt_Cardinality() {
165         setCreatedAt_Cardinality(null);
166     }
167 
168     public void setCreatedAt_Cardinality(ConditionOptionCall<CardinalityAggregationBuilder> opLambda) {
169         setCreatedAt_Cardinality("createdAt", opLambda);
170     }
171 
172     public void setCreatedAt_Cardinality(String name, ConditionOptionCall<CardinalityAggregationBuilder> opLambda) {
173         CardinalityAggregationBuilder builder = regCardinalityA(name, "createdAt");
174         if (opLambda != null) {
175             opLambda.callback(builder);
176         }
177     }
178 
179     public void setCreatedAt_Missing() {
180         setCreatedAt_Missing(null);
181     }
182 
183     public void setCreatedAt_Missing(ConditionOptionCall<MissingAggregationBuilder> opLambda) {
184         setCreatedAt_Missing("createdAt", opLambda, null);
185     }
186 
187     public void setCreatedAt_Missing(ConditionOptionCall<MissingAggregationBuilder> opLambda, OperatorCall<BsUserInfoCA> aggsLambda) {
188         setCreatedAt_Missing("createdAt", opLambda, aggsLambda);
189     }
190 
191     public void setCreatedAt_Missing(String name, ConditionOptionCall<MissingAggregationBuilder> opLambda,
192             OperatorCall<BsUserInfoCA> aggsLambda) {
193         MissingAggregationBuilder builder = regMissingA(name, "createdAt");
194         if (opLambda != null) {
195             opLambda.callback(builder);
196         }
197         if (aggsLambda != null) {
198             UserInfoCA ca = new UserInfoCA();
199             aggsLambda.callback(ca);
200             ca.getAggregationBuilderList().forEach(builder::subAggregation);
201         }
202     }
203 
204     public void setUpdatedAt_DateRange() {
205         setUpdatedAt_DateRange(null);
206     }
207 
208     public void setUpdatedAt_DateRange(ConditionOptionCall<DateRangeAggregationBuilder> opLambda) {
209         setUpdatedAt_DateRange("updatedAt", opLambda, null);
210     }
211 
212     public void setUpdatedAt_DateRange(ConditionOptionCall<DateRangeAggregationBuilder> opLambda, OperatorCall<BsUserInfoCA> aggsLambda) {
213         setUpdatedAt_DateRange("updatedAt", opLambda, aggsLambda);
214     }
215 
216     public void setUpdatedAt_DateRange(String name, ConditionOptionCall<DateRangeAggregationBuilder> opLambda,
217             OperatorCall<BsUserInfoCA> aggsLambda) {
218         DateRangeAggregationBuilder builder = regDateRangeA(name, "updatedAt");
219         if (opLambda != null) {
220             opLambda.callback(builder);
221         }
222         if (aggsLambda != null) {
223             UserInfoCA ca = new UserInfoCA();
224             aggsLambda.callback(ca);
225             ca.getAggregationBuilderList().forEach(builder::subAggregation);
226         }
227     }
228 
229     public void setUpdatedAt_DateHistogram() {
230         setUpdatedAt_DateHistogram(null);
231     }
232 
233     public void setUpdatedAt_DateHistogram(ConditionOptionCall<DateHistogramAggregationBuilder> opLambda) {
234         setUpdatedAt_DateHistogram("updatedAt", opLambda, null);
235     }
236 
237     public void setUpdatedAt_DateHistogram(ConditionOptionCall<DateHistogramAggregationBuilder> opLambda,
238             OperatorCall<BsUserInfoCA> aggsLambda) {
239         setUpdatedAt_DateHistogram("updatedAt", opLambda, aggsLambda);
240     }
241 
242     public void setUpdatedAt_DateHistogram(String name, ConditionOptionCall<DateHistogramAggregationBuilder> opLambda,
243             OperatorCall<BsUserInfoCA> aggsLambda) {
244         DateHistogramAggregationBuilder builder = regDateHistogramA(name, "updatedAt");
245         if (opLambda != null) {
246             opLambda.callback(builder);
247         }
248         if (aggsLambda != null) {
249             UserInfoCA ca = new UserInfoCA();
250             aggsLambda.callback(ca);
251             ca.getAggregationBuilderList().forEach(builder::subAggregation);
252         }
253     }
254 
255     public void setUpdatedAt_Count() {
256         setUpdatedAt_Count(null);
257     }
258 
259     public void setUpdatedAt_Count(ConditionOptionCall<ValueCountAggregationBuilder> opLambda) {
260         setUpdatedAt_Count("updatedAt", opLambda);
261     }
262 
263     public void setUpdatedAt_Count(String name, ConditionOptionCall<ValueCountAggregationBuilder> opLambda) {
264         ValueCountAggregationBuilder builder = regCountA(name, "updatedAt");
265         if (opLambda != null) {
266             opLambda.callback(builder);
267         }
268     }
269 
270     public void setUpdatedAt_Cardinality() {
271         setUpdatedAt_Cardinality(null);
272     }
273 
274     public void setUpdatedAt_Cardinality(ConditionOptionCall<CardinalityAggregationBuilder> opLambda) {
275         setUpdatedAt_Cardinality("updatedAt", opLambda);
276     }
277 
278     public void setUpdatedAt_Cardinality(String name, ConditionOptionCall<CardinalityAggregationBuilder> opLambda) {
279         CardinalityAggregationBuilder builder = regCardinalityA(name, "updatedAt");
280         if (opLambda != null) {
281             opLambda.callback(builder);
282         }
283     }
284 
285     public void setUpdatedAt_Missing() {
286         setUpdatedAt_Missing(null);
287     }
288 
289     public void setUpdatedAt_Missing(ConditionOptionCall<MissingAggregationBuilder> opLambda) {
290         setUpdatedAt_Missing("updatedAt", opLambda, null);
291     }
292 
293     public void setUpdatedAt_Missing(ConditionOptionCall<MissingAggregationBuilder> opLambda, OperatorCall<BsUserInfoCA> aggsLambda) {
294         setUpdatedAt_Missing("updatedAt", opLambda, aggsLambda);
295     }
296 
297     public void setUpdatedAt_Missing(String name, ConditionOptionCall<MissingAggregationBuilder> opLambda,
298             OperatorCall<BsUserInfoCA> aggsLambda) {
299         MissingAggregationBuilder builder = regMissingA(name, "updatedAt");
300         if (opLambda != null) {
301             opLambda.callback(builder);
302         }
303         if (aggsLambda != null) {
304             UserInfoCA ca = new UserInfoCA();
305             aggsLambda.callback(ca);
306             ca.getAggregationBuilderList().forEach(builder::subAggregation);
307         }
308     }
309 
310 }