1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16 package org.codelibs.fess.es.user.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.missing.MissingAggregationBuilder;
21 import org.codelibs.fesen.search.aggregations.bucket.range.IpRangeAggregationBuilder;
22 import org.codelibs.fesen.search.aggregations.bucket.sampler.SamplerAggregationBuilder;
23 import org.codelibs.fesen.search.aggregations.bucket.terms.SignificantTermsAggregationBuilder;
24 import org.codelibs.fesen.search.aggregations.bucket.terms.TermsAggregationBuilder;
25 import org.codelibs.fesen.search.aggregations.metrics.CardinalityAggregationBuilder;
26 import org.codelibs.fesen.search.aggregations.metrics.ScriptedMetricAggregationBuilder;
27 import org.codelibs.fesen.search.aggregations.metrics.TopHitsAggregationBuilder;
28 import org.codelibs.fesen.search.aggregations.metrics.ValueCountAggregationBuilder;
29 import org.codelibs.fess.es.user.allcommon.EsAbstractConditionAggregation;
30 import org.codelibs.fess.es.user.allcommon.EsAbstractConditionQuery;
31 import org.codelibs.fess.es.user.cbean.ca.RoleCA;
32 import org.codelibs.fess.es.user.cbean.cq.RoleCQ;
33 import org.codelibs.fess.es.user.cbean.cq.bs.BsRoleCQ;
34
35
36
37
38 public abstract class BsRoleCA extends EsAbstractConditionAggregation {
39
40
41
42
43
44 public void filter(String name, EsAbstractConditionQuery.OperatorCall<BsRoleCQ> queryLambda,
45 ConditionOptionCall<FilterAggregationBuilder> opLambda, OperatorCall<BsRoleCA> aggsLambda) {
46 RoleCQ cq = new RoleCQ();
47 if (queryLambda != null) {
48 queryLambda.callback(cq);
49 }
50 FilterAggregationBuilder builder = regFilterA(name, cq.getQuery());
51 if (opLambda != null) {
52 opLambda.callback(builder);
53 }
54 if (aggsLambda != null) {
55 RoleCA ca = new RoleCA();
56 aggsLambda.callback(ca);
57 ca.getAggregationBuilderList().forEach(builder::subAggregation);
58 }
59 }
60
61 public void global(String name, ConditionOptionCall<GlobalAggregationBuilder> opLambda, OperatorCall<BsRoleCA> aggsLambda) {
62 GlobalAggregationBuilder builder = regGlobalA(name);
63 if (opLambda != null) {
64 opLambda.callback(builder);
65 }
66 if (aggsLambda != null) {
67 RoleCA ca = new RoleCA();
68 aggsLambda.callback(ca);
69 ca.getAggregationBuilderList().forEach(builder::subAggregation);
70 }
71 }
72
73 public void sampler(String name, ConditionOptionCall<SamplerAggregationBuilder> opLambda, OperatorCall<BsRoleCA> aggsLambda) {
74 SamplerAggregationBuilder builder = regSamplerA(name);
75 if (opLambda != null) {
76 opLambda.callback(builder);
77 }
78 if (aggsLambda != null) {
79 RoleCA ca = new RoleCA();
80 aggsLambda.callback(ca);
81 ca.getAggregationBuilderList().forEach(builder::subAggregation);
82 }
83 }
84
85 public void scriptedMetric(String name, ConditionOptionCall<ScriptedMetricAggregationBuilder> opLambda) {
86 ScriptedMetricAggregationBuilder builder = regScriptedMetricA(name);
87 if (opLambda != null) {
88 opLambda.callback(builder);
89 }
90 }
91
92 public void topHits(String name, ConditionOptionCall<TopHitsAggregationBuilder> opLambda) {
93 TopHitsAggregationBuilder builder = regTopHitsA(name);
94 if (opLambda != null) {
95 opLambda.callback(builder);
96 }
97 }
98
99 public void setName_Terms() {
100 setName_Terms(null);
101 }
102
103 public void setName_Terms(ConditionOptionCall<TermsAggregationBuilder> opLambda) {
104 setName_Terms("name", opLambda, null);
105 }
106
107 public void setName_Terms(ConditionOptionCall<TermsAggregationBuilder> opLambda, OperatorCall<BsRoleCA> aggsLambda) {
108 setName_Terms("name", opLambda, aggsLambda);
109 }
110
111 public void setName_Terms(String name, ConditionOptionCall<TermsAggregationBuilder> opLambda, OperatorCall<BsRoleCA> aggsLambda) {
112 TermsAggregationBuilder builder = regTermsA(name, "name");
113 if (opLambda != null) {
114 opLambda.callback(builder);
115 }
116 if (aggsLambda != null) {
117 RoleCA ca = new RoleCA();
118 aggsLambda.callback(ca);
119 ca.getAggregationBuilderList().forEach(builder::subAggregation);
120 }
121 }
122
123 public void setName_SignificantTerms() {
124 setName_SignificantTerms(null);
125 }
126
127 public void setName_SignificantTerms(ConditionOptionCall<SignificantTermsAggregationBuilder> opLambda) {
128 setName_SignificantTerms("name", opLambda, null);
129 }
130
131 public void setName_SignificantTerms(ConditionOptionCall<SignificantTermsAggregationBuilder> opLambda,
132 OperatorCall<BsRoleCA> aggsLambda) {
133 setName_SignificantTerms("name", opLambda, aggsLambda);
134 }
135
136 public void setName_SignificantTerms(String name, ConditionOptionCall<SignificantTermsAggregationBuilder> opLambda,
137 OperatorCall<BsRoleCA> aggsLambda) {
138 SignificantTermsAggregationBuilder builder = regSignificantTermsA(name, "name");
139 if (opLambda != null) {
140 opLambda.callback(builder);
141 }
142 if (aggsLambda != null) {
143 RoleCA ca = new RoleCA();
144 aggsLambda.callback(ca);
145 ca.getAggregationBuilderList().forEach(builder::subAggregation);
146 }
147 }
148
149 public void setName_IpRange() {
150 setName_IpRange(null);
151 }
152
153 public void setName_IpRange(ConditionOptionCall<IpRangeAggregationBuilder> opLambda) {
154 setName_IpRange("name", opLambda, null);
155 }
156
157 public void setName_IpRange(ConditionOptionCall<IpRangeAggregationBuilder> opLambda, OperatorCall<BsRoleCA> aggsLambda) {
158 setName_IpRange("name", opLambda, aggsLambda);
159 }
160
161 public void setName_IpRange(String name, ConditionOptionCall<IpRangeAggregationBuilder> opLambda, OperatorCall<BsRoleCA> aggsLambda) {
162 IpRangeAggregationBuilder builder = regIpRangeA(name, "name");
163 if (opLambda != null) {
164 opLambda.callback(builder);
165 }
166 if (aggsLambda != null) {
167 RoleCA ca = new RoleCA();
168 aggsLambda.callback(ca);
169 ca.getAggregationBuilderList().forEach(builder::subAggregation);
170 }
171 }
172
173 public void setName_Count() {
174 setName_Count(null);
175 }
176
177 public void setName_Count(ConditionOptionCall<ValueCountAggregationBuilder> opLambda) {
178 setName_Count("name", opLambda);
179 }
180
181 public void setName_Count(String name, ConditionOptionCall<ValueCountAggregationBuilder> opLambda) {
182 ValueCountAggregationBuilder builder = regCountA(name, "name");
183 if (opLambda != null) {
184 opLambda.callback(builder);
185 }
186 }
187
188 public void setName_Cardinality() {
189 setName_Cardinality(null);
190 }
191
192 public void setName_Cardinality(ConditionOptionCall<CardinalityAggregationBuilder> opLambda) {
193 setName_Cardinality("name", opLambda);
194 }
195
196 public void setName_Cardinality(String name, ConditionOptionCall<CardinalityAggregationBuilder> opLambda) {
197 CardinalityAggregationBuilder builder = regCardinalityA(name, "name");
198 if (opLambda != null) {
199 opLambda.callback(builder);
200 }
201 }
202
203 public void setName_Missing() {
204 setName_Missing(null);
205 }
206
207 public void setName_Missing(ConditionOptionCall<MissingAggregationBuilder> opLambda) {
208 setName_Missing("name", opLambda, null);
209 }
210
211 public void setName_Missing(ConditionOptionCall<MissingAggregationBuilder> opLambda, OperatorCall<BsRoleCA> aggsLambda) {
212 setName_Missing("name", opLambda, aggsLambda);
213 }
214
215 public void setName_Missing(String name, ConditionOptionCall<MissingAggregationBuilder> opLambda, OperatorCall<BsRoleCA> aggsLambda) {
216 MissingAggregationBuilder builder = regMissingA(name, "name");
217 if (opLambda != null) {
218 opLambda.callback(builder);
219 }
220 if (aggsLambda != null) {
221 RoleCA ca = new RoleCA();
222 aggsLambda.callback(ca);
223 ca.getAggregationBuilderList().forEach(builder::subAggregation);
224 }
225 }
226
227 }