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.fesen.index.query.BoolQueryBuilder;
23 import org.codelibs.fesen.index.query.CommonTermsQueryBuilder;
24 import org.codelibs.fesen.index.query.ExistsQueryBuilder;
25 import org.codelibs.fesen.index.query.IdsQueryBuilder;
26 import org.codelibs.fesen.index.query.MatchPhrasePrefixQueryBuilder;
27 import org.codelibs.fesen.index.query.MatchPhraseQueryBuilder;
28 import org.codelibs.fesen.index.query.MatchQueryBuilder;
29 import org.codelibs.fesen.index.query.PrefixQueryBuilder;
30 import org.codelibs.fesen.index.query.RangeQueryBuilder;
31 import org.codelibs.fesen.index.query.RegexpQueryBuilder;
32 import org.codelibs.fesen.index.query.SpanTermQueryBuilder;
33 import org.codelibs.fesen.index.query.TermQueryBuilder;
34 import org.codelibs.fesen.index.query.TermsQueryBuilder;
35 import org.codelibs.fesen.index.query.WildcardQueryBuilder;
36 import org.codelibs.fesen.index.query.functionscore.FunctionScoreQueryBuilder;
37 import org.codelibs.fesen.index.query.functionscore.FunctionScoreQueryBuilder.FilterFunctionBuilder;
38 import org.codelibs.fess.es.user.allcommon.EsAbstractConditionQuery;
39 import org.codelibs.fess.es.user.cbean.cq.RoleCQ;
40 import org.dbflute.cbean.ckey.ConditionKey;
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 = regBoolCQ(mustQuery.getQueryBuilderList(), shouldQuery.getQueryBuilderList(),
113 mustNotQuery.getQueryBuilderList(), filterQuery.getQueryBuilderList());
114 if (opLambda != null) {
115 opLambda.callback(builder);
116 }
117 }
118 }
119
120
121
122
123 public void setId_Equal(String id) {
124 setId_Term(id, null);
125 }
126
127 public void setId_Equal(String id, ConditionOptionCall<TermQueryBuilder> opLambda) {
128 setId_Term(id, opLambda);
129 }
130
131 public void setId_Term(String id) {
132 setId_Term(id, null);
133 }
134
135 public void setId_Term(String id, ConditionOptionCall<TermQueryBuilder> opLambda) {
136 TermQueryBuilder builder = regTermQ("_id", id);
137 if (opLambda != null) {
138 opLambda.callback(builder);
139 }
140 }
141
142 public void setId_NotEqual(String id) {
143 setId_NotTerm(id, null);
144 }
145
146 public void setId_NotTerm(String id) {
147 setId_NotTerm(id, null);
148 }
149
150 public void setId_NotEqual(String id, ConditionOptionCall<BoolQueryBuilder> opLambda) {
151 setId_NotTerm(id, opLambda);
152 }
153
154 public void setId_NotTerm(String id, ConditionOptionCall<BoolQueryBuilder> opLambda) {
155 not(not -> not.setId_Term(id), opLambda);
156 }
157
158 public void setId_Terms(Collection<String> idList) {
159 setId_Terms(idList, null);
160 }
161
162 public void setId_Terms(Collection<String> idList, ConditionOptionCall<IdsQueryBuilder> opLambda) {
163 IdsQueryBuilder builder = regIdsQ(idList);
164 if (opLambda != null) {
165 opLambda.callback(builder);
166 }
167 }
168
169 public void setId_InScope(Collection<String> idList) {
170 setId_Terms(idList, null);
171 }
172
173 public void setId_InScope(Collection<String> idList, ConditionOptionCall<IdsQueryBuilder> opLambda) {
174 setId_Terms(idList, opLambda);
175 }
176
177 public BsRoleCQ addOrderBy_Id_Asc() {
178 regOBA("_id");
179 return this;
180 }
181
182 public BsRoleCQ addOrderBy_Id_Desc() {
183 regOBD("_id");
184 return this;
185 }
186
187 public void setName_Equal(String name) {
188 setName_Term(name, null);
189 }
190
191 public void setName_Equal(String name, ConditionOptionCall<TermQueryBuilder> opLambda) {
192 setName_Term(name, opLambda);
193 }
194
195 public void setName_Term(String name) {
196 setName_Term(name, null);
197 }
198
199 public void setName_Term(String name, ConditionOptionCall<TermQueryBuilder> opLambda) {
200 TermQueryBuilder builder = regTermQ("name", name);
201 if (opLambda != null) {
202 opLambda.callback(builder);
203 }
204 }
205
206 public void setName_NotEqual(String name) {
207 setName_NotTerm(name, null);
208 }
209
210 public void setName_NotTerm(String name) {
211 setName_NotTerm(name, null);
212 }
213
214 public void setName_NotEqual(String name, ConditionOptionCall<BoolQueryBuilder> opLambda) {
215 setName_NotTerm(name, opLambda);
216 }
217
218 public void setName_NotTerm(String name, ConditionOptionCall<BoolQueryBuilder> opLambda) {
219 not(not -> not.setName_Term(name), opLambda);
220 }
221
222 public void setName_Terms(Collection<String> nameList) {
223 setName_Terms(nameList, null);
224 }
225
226 public void setName_Terms(Collection<String> nameList, ConditionOptionCall<TermsQueryBuilder> opLambda) {
227 TermsQueryBuilder builder = regTermsQ("name", nameList);
228 if (opLambda != null) {
229 opLambda.callback(builder);
230 }
231 }
232
233 public void setName_InScope(Collection<String> nameList) {
234 setName_Terms(nameList, null);
235 }
236
237 public void setName_InScope(Collection<String> nameList, ConditionOptionCall<TermsQueryBuilder> opLambda) {
238 setName_Terms(nameList, opLambda);
239 }
240
241 public void setName_Match(String name) {
242 setName_Match(name, null);
243 }
244
245 public void setName_Match(String name, ConditionOptionCall<MatchQueryBuilder> opLambda) {
246 MatchQueryBuilder builder = regMatchQ("name", name);
247 if (opLambda != null) {
248 opLambda.callback(builder);
249 }
250 }
251
252 public void setName_MatchPhrase(String name) {
253 setName_MatchPhrase(name, null);
254 }
255
256 public void setName_MatchPhrase(String name, ConditionOptionCall<MatchPhraseQueryBuilder> opLambda) {
257 MatchPhraseQueryBuilder builder = regMatchPhraseQ("name", name);
258 if (opLambda != null) {
259 opLambda.callback(builder);
260 }
261 }
262
263 public void setName_MatchPhrasePrefix(String name) {
264 setName_MatchPhrasePrefix(name, null);
265 }
266
267 public void setName_MatchPhrasePrefix(String name, ConditionOptionCall<MatchPhrasePrefixQueryBuilder> opLambda) {
268 MatchPhrasePrefixQueryBuilder builder = regMatchPhrasePrefixQ("name", name);
269 if (opLambda != null) {
270 opLambda.callback(builder);
271 }
272 }
273
274 public void setName_Fuzzy(String name) {
275 setName_Fuzzy(name, null);
276 }
277
278 public void setName_Fuzzy(String name, ConditionOptionCall<MatchQueryBuilder> opLambda) {
279 MatchQueryBuilder builder = regFuzzyQ("name", name);
280 if (opLambda != null) {
281 opLambda.callback(builder);
282 }
283 }
284
285 public void setName_Prefix(String name) {
286 setName_Prefix(name, null);
287 }
288
289 public void setName_Prefix(String name, ConditionOptionCall<PrefixQueryBuilder> opLambda) {
290 PrefixQueryBuilder builder = regPrefixQ("name", name);
291 if (opLambda != null) {
292 opLambda.callback(builder);
293 }
294 }
295
296 public void setName_Wildcard(String name) {
297 setName_Wildcard(name, null);
298 }
299
300 public void setName_Wildcard(String name, ConditionOptionCall<WildcardQueryBuilder> opLambda) {
301 WildcardQueryBuilder builder = regWildcardQ("name", name);
302 if (opLambda != null) {
303 opLambda.callback(builder);
304 }
305 }
306
307 public void setName_Regexp(String name) {
308 setName_Regexp(name, null);
309 }
310
311 public void setName_Regexp(String name, ConditionOptionCall<RegexpQueryBuilder> opLambda) {
312 RegexpQueryBuilder builder = regRegexpQ("name", name);
313 if (opLambda != null) {
314 opLambda.callback(builder);
315 }
316 }
317
318 public void setName_SpanTerm(String name) {
319 setName_SpanTerm("name", null);
320 }
321
322 public void setName_SpanTerm(String name, ConditionOptionCall<SpanTermQueryBuilder> opLambda) {
323 SpanTermQueryBuilder builder = regSpanTermQ("name", name);
324 if (opLambda != null) {
325 opLambda.callback(builder);
326 }
327 }
328
329 public void setName_GreaterThan(String name) {
330 setName_GreaterThan(name, null);
331 }
332
333 public void setName_GreaterThan(String name, ConditionOptionCall<RangeQueryBuilder> opLambda) {
334 final Object _value = name;
335 RangeQueryBuilder builder = regRangeQ("name", ConditionKey.CK_GREATER_THAN, _value);
336 if (opLambda != null) {
337 opLambda.callback(builder);
338 }
339 }
340
341 public void setName_LessThan(String name) {
342 setName_LessThan(name, null);
343 }
344
345 public void setName_LessThan(String name, ConditionOptionCall<RangeQueryBuilder> opLambda) {
346 final Object _value = name;
347 RangeQueryBuilder builder = regRangeQ("name", ConditionKey.CK_LESS_THAN, _value);
348 if (opLambda != null) {
349 opLambda.callback(builder);
350 }
351 }
352
353 public void setName_GreaterEqual(String name) {
354 setName_GreaterEqual(name, null);
355 }
356
357 public void setName_GreaterEqual(String name, ConditionOptionCall<RangeQueryBuilder> opLambda) {
358 final Object _value = name;
359 RangeQueryBuilder builder = regRangeQ("name", ConditionKey.CK_GREATER_EQUAL, _value);
360 if (opLambda != null) {
361 opLambda.callback(builder);
362 }
363 }
364
365 public void setName_LessEqual(String name) {
366 setName_LessEqual(name, null);
367 }
368
369 public void setName_LessEqual(String name, ConditionOptionCall<RangeQueryBuilder> opLambda) {
370 final Object _value = name;
371 RangeQueryBuilder builder = regRangeQ("name", ConditionKey.CK_LESS_EQUAL, _value);
372 if (opLambda != null) {
373 opLambda.callback(builder);
374 }
375 }
376
377 public void setName_Exists() {
378 setName_Exists(null);
379 }
380
381 public void setName_Exists(ConditionOptionCall<ExistsQueryBuilder> opLambda) {
382 ExistsQueryBuilder builder = regExistsQ("name");
383 if (opLambda != null) {
384 opLambda.callback(builder);
385 }
386 }
387
388 public void setName_CommonTerms(String name) {
389 setName_CommonTerms(name, null);
390 }
391
392 public void setName_CommonTerms(String name, ConditionOptionCall<CommonTermsQueryBuilder> opLambda) {
393 CommonTermsQueryBuilder builder = regCommonTermsQ("name", name);
394 if (opLambda != null) {
395 opLambda.callback(builder);
396 }
397 }
398
399 public BsRoleCQ addOrderBy_Name_Asc() {
400 regOBA("name");
401 return this;
402 }
403
404 public BsRoleCQ addOrderBy_Name_Desc() {
405 regOBD("name");
406 return this;
407 }
408
409 }