1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16 package org.codelibs.fess.es.user.cbean.cq.bs;
17
18 import java.time.LocalDateTime;
19 import java.util.ArrayList;
20 import java.util.Collection;
21
22 import org.codelibs.fess.es.user.allcommon.EsAbstractConditionQuery;
23 import org.codelibs.fess.es.user.cbean.cq.RoleCQ;
24 import org.dbflute.cbean.ckey.ConditionKey;
25 import org.elasticsearch.index.query.BoolQueryBuilder;
26 import org.elasticsearch.index.query.CommonTermsQueryBuilder;
27 import org.elasticsearch.index.query.ExistsQueryBuilder;
28 import org.elasticsearch.index.query.IdsQueryBuilder;
29 import org.elasticsearch.index.query.MatchPhrasePrefixQueryBuilder;
30 import org.elasticsearch.index.query.MatchPhraseQueryBuilder;
31 import org.elasticsearch.index.query.MatchQueryBuilder;
32 import org.elasticsearch.index.query.PrefixQueryBuilder;
33 import org.elasticsearch.index.query.RangeQueryBuilder;
34 import org.elasticsearch.index.query.RegexpQueryBuilder;
35 import org.elasticsearch.index.query.SpanTermQueryBuilder;
36 import org.elasticsearch.index.query.TermQueryBuilder;
37 import org.elasticsearch.index.query.TermsQueryBuilder;
38 import org.elasticsearch.index.query.WildcardQueryBuilder;
39 import org.elasticsearch.index.query.functionscore.FunctionScoreQueryBuilder;
40 import org.elasticsearch.index.query.functionscore.FunctionScoreQueryBuilder.FilterFunctionBuilder;
41
42
43
44
45 public abstract class BsRoleCQ extends EsAbstractConditionQuery {
46
47 protected static final Class<?> suppressUnusedImportLocalDateTime = LocalDateTime.class;
48
49
50
51
52 @Override
53 public String asTableDbName() {
54 return "role";
55 }
56
57 @Override
58 public String xgetAliasName() {
59 return "role";
60 }
61
62
63
64
65 public void functionScore(OperatorCall<RoleCQ> queryLambda, ScoreFunctionCall<ScoreFunctionCreator<RoleCQ>> functionsLambda,
66 final ConditionOptionCall<FunctionScoreQueryBuilder> opLambda) {
67 RoleCQ cq = new RoleCQ();
68 queryLambda.callback(cq);
69 final Collection<FilterFunctionBuilder> list = new ArrayList<>();
70 if (functionsLambda != null) {
71 functionsLambda.callback((cqLambda, scoreFunctionBuilder) -> {
72 RoleCQ cf = new RoleCQ();
73 cqLambda.callback(cf);
74 list.add(new FilterFunctionBuilder(cf.getQuery(), scoreFunctionBuilder));
75 });
76 }
77 final FunctionScoreQueryBuilder builder = regFunctionScoreQ(cq.getQuery(), list);
78 if (opLambda != null) {
79 opLambda.callback(builder);
80 }
81 }
82
83 public void filtered(FilteredCall<RoleCQ, RoleCQ> filteredLambda) {
84 filtered(filteredLambda, null);
85 }
86
87 public void filtered(FilteredCall<RoleCQ, RoleCQ> filteredLambda, ConditionOptionCall<BoolQueryBuilder> opLambda) {
88 bool((must, should, mustNot, filter) -> {
89 filteredLambda.callback(must, filter);
90 }, opLambda);
91 }
92
93 public void not(OperatorCall<RoleCQ> notLambda) {
94 not(notLambda, null);
95 }
96
97 public void not(final OperatorCall<RoleCQ> notLambda, final ConditionOptionCall<BoolQueryBuilder> opLambda) {
98 bool((must, should, mustNot, filter) -> notLambda.callback(mustNot), opLambda);
99 }
100
101 public void bool(BoolCall<RoleCQ> boolLambda) {
102 bool(boolLambda, null);
103 }
104
105 public void bool(BoolCall<RoleCQ> boolLambda, ConditionOptionCall<BoolQueryBuilder> opLambda) {
106 RoleCQ mustQuery = new RoleCQ();
107 RoleCQ shouldQuery = new RoleCQ();
108 RoleCQ mustNotQuery = new RoleCQ();
109 RoleCQ filterQuery = new RoleCQ();
110 boolLambda.callback(mustQuery, shouldQuery, mustNotQuery, filterQuery);
111 if (mustQuery.hasQueries() || shouldQuery.hasQueries() || mustNotQuery.hasQueries() || filterQuery.hasQueries()) {
112 BoolQueryBuilder builder =
113 regBoolCQ(mustQuery.getQueryBuilderList(), shouldQuery.getQueryBuilderList(), mustNotQuery.getQueryBuilderList(),
114 filterQuery.getQueryBuilderList());
115 if (opLambda != null) {
116 opLambda.callback(builder);
117 }
118 }
119 }
120
121
122
123
124 public void setId_Equal(String id) {
125 setId_Term(id, null);
126 }
127
128 public void setId_Equal(String id, ConditionOptionCall<TermQueryBuilder> opLambda) {
129 setId_Term(id, opLambda);
130 }
131
132 public void setId_Term(String id) {
133 setId_Term(id, null);
134 }
135
136 public void setId_Term(String id, ConditionOptionCall<TermQueryBuilder> opLambda) {
137 TermQueryBuilder builder = regTermQ("_id", id);
138 if (opLambda != null) {
139 opLambda.callback(builder);
140 }
141 }
142
143 public void setId_NotEqual(String id) {
144 setId_NotTerm(id, null);
145 }
146
147 public void setId_NotTerm(String id) {
148 setId_NotTerm(id, null);
149 }
150
151 public void setId_NotEqual(String id, ConditionOptionCall<BoolQueryBuilder> opLambda) {
152 setId_NotTerm(id, opLambda);
153 }
154
155 public void setId_NotTerm(String id, ConditionOptionCall<BoolQueryBuilder> opLambda) {
156 not(not -> not.setId_Term(id), opLambda);
157 }
158
159 public void setId_Terms(Collection<String> idList) {
160 setId_Terms(idList, null);
161 }
162
163 public void setId_Terms(Collection<String> idList, ConditionOptionCall<IdsQueryBuilder> opLambda) {
164 IdsQueryBuilder builder = regIdsQ(idList);
165 if (opLambda != null) {
166 opLambda.callback(builder);
167 }
168 }
169
170 public void setId_InScope(Collection<String> idList) {
171 setId_Terms(idList, null);
172 }
173
174 public void setId_InScope(Collection<String> idList, ConditionOptionCall<IdsQueryBuilder> opLambda) {
175 setId_Terms(idList, opLambda);
176 }
177
178 public BsRoleCQ addOrderBy_Id_Asc() {
179 regOBA("_uid");
180 return this;
181 }
182
183 public BsRoleCQ addOrderBy_Id_Desc() {
184 regOBD("_uid");
185 return this;
186 }
187
188 public void setName_Equal(String name) {
189 setName_Term(name, null);
190 }
191
192 public void setName_Equal(String name, ConditionOptionCall<TermQueryBuilder> opLambda) {
193 setName_Term(name, opLambda);
194 }
195
196 public void setName_Term(String name) {
197 setName_Term(name, null);
198 }
199
200 public void setName_Term(String name, ConditionOptionCall<TermQueryBuilder> opLambda) {
201 TermQueryBuilder builder = regTermQ("name", name);
202 if (opLambda != null) {
203 opLambda.callback(builder);
204 }
205 }
206
207 public void setName_NotEqual(String name) {
208 setName_NotTerm(name, null);
209 }
210
211 public void setName_NotTerm(String name) {
212 setName_NotTerm(name, null);
213 }
214
215 public void setName_NotEqual(String name, ConditionOptionCall<BoolQueryBuilder> opLambda) {
216 setName_NotTerm(name, opLambda);
217 }
218
219 public void setName_NotTerm(String name, ConditionOptionCall<BoolQueryBuilder> opLambda) {
220 not(not -> not.setName_Term(name), opLambda);
221 }
222
223 public void setName_Terms(Collection<String> nameList) {
224 setName_Terms(nameList, null);
225 }
226
227 public void setName_Terms(Collection<String> nameList, ConditionOptionCall<TermsQueryBuilder> opLambda) {
228 TermsQueryBuilder builder = regTermsQ("name", nameList);
229 if (opLambda != null) {
230 opLambda.callback(builder);
231 }
232 }
233
234 public void setName_InScope(Collection<String> nameList) {
235 setName_Terms(nameList, null);
236 }
237
238 public void setName_InScope(Collection<String> nameList, ConditionOptionCall<TermsQueryBuilder> opLambda) {
239 setName_Terms(nameList, opLambda);
240 }
241
242 public void setName_Match(String name) {
243 setName_Match(name, null);
244 }
245
246 public void setName_Match(String name, ConditionOptionCall<MatchQueryBuilder> opLambda) {
247 MatchQueryBuilder builder = regMatchQ("name", name);
248 if (opLambda != null) {
249 opLambda.callback(builder);
250 }
251 }
252
253 public void setName_MatchPhrase(String name) {
254 setName_MatchPhrase(name, null);
255 }
256
257 public void setName_MatchPhrase(String name, ConditionOptionCall<MatchPhraseQueryBuilder> opLambda) {
258 MatchPhraseQueryBuilder builder = regMatchPhraseQ("name", name);
259 if (opLambda != null) {
260 opLambda.callback(builder);
261 }
262 }
263
264 public void setName_MatchPhrasePrefix(String name) {
265 setName_MatchPhrasePrefix(name, null);
266 }
267
268 public void setName_MatchPhrasePrefix(String name, ConditionOptionCall<MatchPhrasePrefixQueryBuilder> opLambda) {
269 MatchPhrasePrefixQueryBuilder builder = regMatchPhrasePrefixQ("name", name);
270 if (opLambda != null) {
271 opLambda.callback(builder);
272 }
273 }
274
275 public void setName_Fuzzy(String name) {
276 setName_Fuzzy(name, null);
277 }
278
279 public void setName_Fuzzy(String name, ConditionOptionCall<MatchQueryBuilder> opLambda) {
280 MatchQueryBuilder builder = regFuzzyQ("name", name);
281 if (opLambda != null) {
282 opLambda.callback(builder);
283 }
284 }
285
286 public void setName_Prefix(String name) {
287 setName_Prefix(name, null);
288 }
289
290 public void setName_Prefix(String name, ConditionOptionCall<PrefixQueryBuilder> opLambda) {
291 PrefixQueryBuilder builder = regPrefixQ("name", name);
292 if (opLambda != null) {
293 opLambda.callback(builder);
294 }
295 }
296
297 public void setName_Wildcard(String name) {
298 setName_Wildcard(name, null);
299 }
300
301 public void setName_Wildcard(String name, ConditionOptionCall<WildcardQueryBuilder> opLambda) {
302 WildcardQueryBuilder builder = regWildcardQ("name", name);
303 if (opLambda != null) {
304 opLambda.callback(builder);
305 }
306 }
307
308 public void setName_Regexp(String name) {
309 setName_Regexp(name, null);
310 }
311
312 public void setName_Regexp(String name, ConditionOptionCall<RegexpQueryBuilder> opLambda) {
313 RegexpQueryBuilder builder = regRegexpQ("name", name);
314 if (opLambda != null) {
315 opLambda.callback(builder);
316 }
317 }
318
319 public void setName_SpanTerm(String name) {
320 setName_SpanTerm("name", null);
321 }
322
323 public void setName_SpanTerm(String name, ConditionOptionCall<SpanTermQueryBuilder> opLambda) {
324 SpanTermQueryBuilder builder = regSpanTermQ("name", name);
325 if (opLambda != null) {
326 opLambda.callback(builder);
327 }
328 }
329
330 public void setName_GreaterThan(String name) {
331 setName_GreaterThan(name, null);
332 }
333
334 public void setName_GreaterThan(String name, ConditionOptionCall<RangeQueryBuilder> opLambda) {
335 final Object _value = name;
336 RangeQueryBuilder builder = regRangeQ("name", ConditionKey.CK_GREATER_THAN, _value);
337 if (opLambda != null) {
338 opLambda.callback(builder);
339 }
340 }
341
342 public void setName_LessThan(String name) {
343 setName_LessThan(name, null);
344 }
345
346 public void setName_LessThan(String name, ConditionOptionCall<RangeQueryBuilder> opLambda) {
347 final Object _value = name;
348 RangeQueryBuilder builder = regRangeQ("name", ConditionKey.CK_LESS_THAN, _value);
349 if (opLambda != null) {
350 opLambda.callback(builder);
351 }
352 }
353
354 public void setName_GreaterEqual(String name) {
355 setName_GreaterEqual(name, null);
356 }
357
358 public void setName_GreaterEqual(String name, ConditionOptionCall<RangeQueryBuilder> opLambda) {
359 final Object _value = name;
360 RangeQueryBuilder builder = regRangeQ("name", ConditionKey.CK_GREATER_EQUAL, _value);
361 if (opLambda != null) {
362 opLambda.callback(builder);
363 }
364 }
365
366 public void setName_LessEqual(String name) {
367 setName_LessEqual(name, null);
368 }
369
370 public void setName_LessEqual(String name, ConditionOptionCall<RangeQueryBuilder> opLambda) {
371 final Object _value = name;
372 RangeQueryBuilder builder = regRangeQ("name", ConditionKey.CK_LESS_EQUAL, _value);
373 if (opLambda != null) {
374 opLambda.callback(builder);
375 }
376 }
377
378 public void setName_Exists() {
379 setName_Exists(null);
380 }
381
382 public void setName_Exists(ConditionOptionCall<ExistsQueryBuilder> opLambda) {
383 ExistsQueryBuilder builder = regExistsQ("name");
384 if (opLambda != null) {
385 opLambda.callback(builder);
386 }
387 }
388
389 public void setName_CommonTerms(String name) {
390 setName_CommonTerms(name, null);
391 }
392
393 public void setName_CommonTerms(String name, ConditionOptionCall<CommonTermsQueryBuilder> opLambda) {
394 CommonTermsQueryBuilder builder = regCommonTermsQ("name", name);
395 if (opLambda != null) {
396 opLambda.callback(builder);
397 }
398 }
399
400 public BsRoleCQ addOrderBy_Name_Asc() {
401 regOBA("name");
402 return this;
403 }
404
405 public BsRoleCQ addOrderBy_Name_Desc() {
406 regOBD("name");
407 return this;
408 }
409
410 }